개발 관련

[C#] DataGridView Header Cell Merge

DevReff — Tue, 31 Mar 2026 08:25:04 +0900

1. 호출하는 코드

private void dgvView_Paint(object sender, PaintEventArgs e)
{
//DgvColumnHeaderCellMerge(dgvView, e, StringAlignment.Center, "Header Merge", 2, 2);
var infos = new List<HeaderCellMerge.DgvHeaderCellMergeInfo>
{
new HeaderCellMerge.DgvHeaderCellMergeInfo { Align = StringAlignment.Center, Header = "Header Merge1", StartColIdx = 2, MergeCnt = 2 },
new HeaderCellMerge.DgvHeaderCellMergeInfo { Align = StringAlignment.Center, Header = "Header Merge2", StartColIdx = 4, MergeCnt = 3 }
};
HeaderCellMerge.DgvColumnHeaderCellMerge(dgvView, e, infos);
}

2. 소스

namespace DgvCellMergeHelper
{
public class HeaderCellMerge
{
/// <summary>
/// DataGridView Column Header Cell 병합
/// <para>- 생성자에서 칼럼헤더의 높이를 적당히(2배) 설정함.</para>
/// <para>- DataGridView의 Paint 이벤트에서 호출하면 됨.</para>
/// </summary>
/// <param name="dgv"></param>
/// <param name="e"></param>
/// <param name="align"></param>
/// <param name="header"></param>
/// <param name="startColIdx"></param>
/// <param name="mergeCnt"></param>
public static void DgvColumnHeaderCellMerge(DataGridView dgv, PaintEventArgs e, StringAlignment align, string header, int startColIdx, int mergeCnt)
{
try
{
if (dgv.Columns.Count < startColIdx + mergeCnt)
return;

DataGridViewContentAlignment ca = align == StringAlignment.Near
? DataGridViewContentAlignment.BottomLeft
: align == StringAlignment.Center
? DataGridViewContentAlignment.BottomCenter
: DataGridViewContentAlignment.BottomRight;
Rectangle r1 = dgv.GetCellDisplayRectangle(startColIdx, -1, true);
var cell = dgv.Columns[startColIdx].HeaderCell;
cell.Style.Alignment = ca;

int w2 = 0;
for (int i = 1; i < mergeCnt; ++i)
{
cell = dgv.Columns[startColIdx + i].HeaderCell;
if (cell != null)
cell.Style.Alignment = ca;

w2 += dgv.GetCellDisplayRectangle(startColIdx + i, -1, true).Width;
}

r1.X += 1;
r1.Y += 1;
r1.Width = r1.Width + w2 - 2;
r1.Height = r1.Height / 2 - 2;

// Fill and draw the merged text
using (SolidBrush brush = new SolidBrush(dgv.ColumnHeadersDefaultCellStyle.BackColor))
{
e.Graphics.FillRectangle(brush, r1);
}

StringFormat format = new StringFormat { Alignment = align, LineAlignment = align };
e.Graphics.DrawString(header, dgv.ColumnHeadersDefaultCellStyle.Font, new SolidBrush(dgv.ColumnHeadersDefaultCellStyle.ForeColor), r1, format);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}

/// <summary>
/// DataGridView Column Header Cell 다중병합
/// <para>- 생성자에서 칼럼헤더의 높이를 적당히(2배) 설정함.</para>
/// <para>- DataGridView의 Paint 이벤트에서 호출하면 됨.</para>
/// </summary>
/// <param name="dgv"></param>
/// <param name="e"></param>
/// <param name="infos"></param>
public static void DgvColumnHeaderCellMerge(DataGridView dgv, PaintEventArgs e, List<DgvHeaderCellMergeInfo> infos)
{
try
{
foreach (var v in infos)
{
if (dgv.Columns.Count < v.StartColIdx + v.MergeCnt)
return;
DataGridViewContentAlignment ca = v.Align == StringAlignment.Near
? DataGridViewContentAlignment.BottomLeft
: v.Align == StringAlignment.Center
? DataGridViewContentAlignment.BottomCenter
: DataGridViewContentAlignment.BottomRight;
Rectangle r1 = dgv.GetCellDisplayRectangle(v.StartColIdx, -1, true);
var cell = dgv.Columns[v.StartColIdx].HeaderCell;
cell.Style.Alignment = ca;

int w2 = 0;
for (int i = 1; i < v.MergeCnt; ++i)
{
cell = dgv.Columns[v.StartColIdx + i].HeaderCell;
if (cell != null)
cell.Style.Alignment = ca;

w2 += dgv.GetCellDisplayRectangle(v.StartColIdx + i, -1, true).Width;
}

r1.X += 1;
r1.Y += 1;
r1.Width = r1.Width + w2 - 2;
r1.Height = r1.Height / 2 - 2;

// Fill and draw the merged text
using (SolidBrush brush = new SolidBrush(dgv.ColumnHeadersDefaultCellStyle.BackColor))
{
e.Graphics.FillRectangle(brush, r1);
}

StringFormat format = new StringFormat { Alignment = v.Align, LineAlignment = v.Align };
e.Graphics.DrawString(v.Header, dgv.ColumnHeadersDefaultCellStyle.Font, new SolidBrush(dgv.ColumnHeadersDefaultCellStyle.ForeColor), r1, format);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}

/// <summary>
/// DataGridView Column Header Cell Merge Info
/// </summary>
public class DgvHeaderCellMergeInfo
{
public StringAlignment Align { get; set; }
public string Header { get; set; }
public int StartColIdx { get; set; }
public int MergeCnt { get; set; }
}

}
}

참조) https://harrymom.tistory.com/m/8

[DB] Firebird 2.5버전을 5.0버전으로 업그레이드 하는 방법

DevReff — Wed, 18 Feb 2026 10:46:05 +0900

1. DB를 .fbk로 백업
1) 명령프롬프트를 관리자권한으로 실행 후 2.5 설치 폴더\bin으로 이동함
2) 백업명령 실행함 (gbak -b -v -user [아이디] -password [암호] 백업할파일 백업후파일)
예: gbak -b -v -user SYSDBA -password masterkey "localhost:C:\test\Data\test.gdb" "C:\test\Data\test.fbk"

2. C:\saem\Data\ 폴더에 수정 권한을 가지고 있는지 반드시 확인 후 권한이 없으면 수정 권한 부여

3. 5.0 설치
설치 전 이전 버전의 설치 파일 및 폴더를 삭제한다.

4. 5.0 설치 폴더 내의 설정 파일 (firebird.conf) 내용 수정
1) 실행되고 있으면 Shutdown함
2) firebird.conf 파일안에서 AuthServer 항목에 Legacy_Auth 추가
3) firebird.conf 파일안에서 UserManager 항목에 Legacy_UserManager 추가
예:
AuthServer = Srp256, Srp, Legacy_Auth
UserManager = Srp, Legacy_UserManager

5. 복구
1) 5.0이 실행되고 있지않으면 실행함
2) 명령프롬프트를 관리자권한으로 실행 후 5.0 설치 폴더로 이동함
3) 복구명령을 실행함 (gbak -c -v -user [아이디] -password [암호] 복구할파일 복구후파일)
예: gbak -c -v -user SYSDBA -password masterkey "C:\test\Data\test.fbk" "localhost:C:\test\Data\test.fdb"

[C#] 빈문자열 출력이 가능한 NumericUpDown 컨트롤 만들기

DevReff — Sun, 6 Jul 2025 12:52:38 +0900

1. 소스

public partial class CjNud : UserControl
{
    #region 이벤트 핸들러
    /// <summary>
    /// 값이 변경되었을 때 발생하는 이벤트핸들러
    /// </summary>
    public event EventHandler ValueChanged;
    #endregion

    #region Attributes
    /// <summary>
    /// 값의 자리수 (숫자의 좌측 빈자리를 0으로 채움, default=2)
    /// </summary>
    private int m_nDigits = 2;
    [Browsable(true)]
    [Category("Data")]
    [Description("값의 자리수 (숫자의 좌측 빈자리를 0으로 채움)")]
    public int Digits
    {
        get { return m_nDigits; }
        set
        {
            m_nDigits = value;

            if (this.DesignMode)
                SetMaxLength();
        }
    }

    /// <summary>
    /// 값이 0일 때 빈문자열을 표시할지 여부
    /// </summary>
    private bool m_bExistsEmpty;
    [Browsable(true)]
    [Category("Data")]
    [Description("값이 0일 때 빈문자열을 표시할지 여부")]
    public bool ExistsEmpty
    {
        get { return m_bExistsEmpty; }
        set { m_bExistsEmpty = value; if (this.DesignMode) Invalidate(); }
    }

    /// <summary>
    /// 최소값 (default=0)
    /// </summary>
    private int m_Min = 0;
    [Browsable(true)]
    [Category("Data")]
    [Description("최소값")]
    [DefaultValue(0)]
    public int Min
    {
        get { return m_Min; }
        set { m_Min = value; }
    }

    /// <summary>
    /// 최대값 (default=99)
    /// </summary>
    private int m_Max = 99;
    [Browsable(true)]
    [Category("Data")]
    [Description("최대값")]
    [DefaultValue(99)]
    public int Max
    {
        get { return m_Max; }
        set { m_Max = value; }
    }

    /// <summary>
    /// 현재 값
    /// </summary>
    private int m_nValue = 0;
    [Browsable(true)]
    [Category("Data")]
    [Description("현재 값")]
    public int Value
    {
        get { return m_nValue; }
        set
        {
            m_nValue = value;

            if (this.DesignMode)
                DisplayValue();
        }
    }

    [Browsable(true)]
    [Category("Data")]
    [Description("현재 문자열 값")]
    public string DataValue
    {
        get
        {
            if (Digits == 0)
                return Value.ToString();
            else
                return Value.ToString($"D{Digits}");
        }
        set
        {
            try
            {
                if (!string.IsNullOrWhiteSpace(value) &&
                    int.TryParse(value.ToString(), out int nValue))
                    Value = nValue;
                else
                    Value = 0;

                if (this.DesignMode)
                    DisplayValue();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }
    }

    /// <summary>
    /// 경계선 존재여부 (default=true)
    /// </summary>
    private bool m_bOutline = true;
    [Browsable(true)]
    [Category("Data")]
    [Description("경계선 존재여부")]
    [DefaultValue(true)]
    public bool Outline
    {
        get { return m_bOutline; }
        set { m_bOutline = value; if (this.DesignMode) Invalidate(); }
    }

    /// <summary>
    /// 경계선의 색상 (default=검정색)
    /// </summary>
    private Color m_outlineColor = Color.Black;
    [Browsable(true)]
    [Category("Data")]
    [Description("경계선의 색상")]
    public Color OutlineColor
    {
        get { return m_outlineColor; }
        set { m_outlineColor = value; if (this.DesignMode) Invalidate(); }
    }

    /// <summary>
    /// 배경색
    /// </summary>
    private Color m_crBack = SystemColors.Control;
    [Browsable(true)]
    [Category("Data")]
    [Description("배경색")]
    public Color ColorBack
    {
        get { return m_crBack; }
        set
        {
            m_crBack = value; if (this.DesignMode) Invalidate();
        }
    }
    /// <summary>
    /// 글자색
    /// </summary>
    private Color m_crFore = SystemColors.WindowText;
    [Browsable(true)]
    [Category("Data")]
    [Description("글자색")]
    public Color ColorFore
    {
        get { return m_crFore; }
        set
        {
            m_crFore = value; if (this.DesignMode) Invalidate();
        }
    }

    /// <summary>
    /// 증가 버튼 문자열
    /// </summary>
    private string m_strBtnUp = "▲";
    /// <summary>
    /// 감소 버튼 문자열
    /// </summary>
    private string m_strBtnDn = "▼";

    /// <summary>
    /// Up버튼의 배경 이미지
    /// </summary>
    private Image m_imgBtnUp = null;
    [Browsable(true)]
    [Category("Data")]
    [Description("Up버튼의 배경 이미지")]
    public Image BtnUpImage
    {
        get { return m_imgBtnUp; }
        set
        {
            m_imgBtnUp = value; if (this.DesignMode) Invalidate();
        }
    }

    /// <summary>
    /// Down버튼의 배경 이미지
    /// </summary>
    private Image m_imgBtnDown = null;
    [Browsable(true)]
    [Category("Data")]
    [Description("Down버튼의 배경 이미지")]
    public Image BtnDnImage
    {
        get { return m_imgBtnDown; }
        set
        {
            m_imgBtnDown = value; if (this.DesignMode) Invalidate();
        }
    }
    #endregion

    #region 생성자
    /// <summary>
    /// 생성자
    /// </summary>
    public CjNud()
    {
        InitializeComponent();
    }
    #endregion

    #region 컨트롤 이벤트 처리
    /// <summary>
    /// 컨트롤이 표시되기 전
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void CjNud_Load(object sender, EventArgs e)
    {
        SetColor(m_crBack, m_crFore);
        SetBtnImage(BtnUpImage, BtnDnImage);
        SetMaxLength();
        DisplayValue();
    }

    /// <summary>
    /// WM_PAINT 메시지 발생시
    /// </summary>
    /// <param name="e"></param>
    protected override void OnPaint(PaintEventArgs e)
    {
        if (m_bOutline)
            ControlPaint.DrawBorder(e.Graphics, ClientRectangle, m_outlineColor, ButtonBorderStyle.Solid);
    }

    /// <summary>
    /// 증가 버튼 클릭시
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void BtnUp_Click(object sender, EventArgs e)
    {
        try
        {
            if (Value < Max)
            {
                ++Value;
                DisplayValue();
                ValueChanged?.Invoke(this, e);
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 감소 버튼 클릭시
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void BtnDn_Click(object sender, EventArgs e)
    {
        try
        {
            if (Value > Min)
            {
                --Value;
                DisplayValue();
                ValueChanged?.Invoke(this, e);
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 값 입력 컨트롤에 키가 입력되었을 때
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void TxbValue_KeyPress(object sender, KeyPressEventArgs e)
    {
        try
        {
            if (e.KeyChar == 13) //엔터키를 눌렀을 때
            {
                if (int.TryParse(TxbValue.Text, out int nValue))
                {
                    Value = nValue;
                    DisplayValue();
                    ValueChanged?.Invoke(this, e);
                }
                else
                {
                    DisplayValue();
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 값 입력 컨트롤을 벗어났을 때
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void TxbValue_Leave(object sender, EventArgs e)
    {
        try
        {
            if (int.TryParse(TxbValue.Text, out int nValue))
            {
                Value = nValue;
                DisplayValue();
                ValueChanged?.Invoke(this, e);
            }
            else
            {
                DisplayValue();
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }
    #endregion

    #region 외부함수
    /// <summary>
    /// 빈문자열로 화면 표시하기
    /// </summary>
    public void EmptyDisplay()
    {
        try
        {
            Value = Min;

            if (this.InvokeRequired)
                BeginInvoke(new Action(() =>
                {
                    if (ExistsEmpty)
                        TxbValue.Text = "";
                    else
                    {
                        if (Digits == 0)
                            TxbValue.Text = Value.ToString();
                        else
                            TxbValue.Text = Value.ToString($"D{Digits}");
                    }
                }));
            else
            {
                if (ExistsEmpty)
                    TxbValue.Text = "";
                else
                {
                    if (Digits == 0)
                        TxbValue.Text = Value.ToString();
                    else
                        TxbValue.Text = Value.ToString($"D{Digits}");
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 값을 화면에 표시하기
    /// </summary>
    public void DisplayValue()
    {
        try
        {
            if (this.InvokeRequired)
                BeginInvoke(new Action(() =>
                {
                    if (Digits == 0)
                        TxbValue.Text = Value.ToString();
                    else
                        TxbValue.Text = Value.ToString($"D{Digits}");
                }));
            else
            {
                if (Digits == 0)
                    TxbValue.Text = Value.ToString();
                else
                    TxbValue.Text = Value.ToString($"D{Digits}");
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 입력할 수 있는 최대 자리수 설정하기
    /// </summary>
    public void SetMaxLength()
    {
        try
        {
            if (this.InvokeRequired)
                BeginInvoke(new Action(() =>
                {
                    TxbValue.MaxLength = Digits;
                }));
            else
                TxbValue.MaxLength = Digits;
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 버튼 이미지 설정하기
    /// </summary>
    /// <param name="btnUp">증가 버튼 이미지</param>
    /// <param name="btnDn">감소 버튼 이미지</param>
    public void SetBtnImage(Image btnUp, Image btnDn)
    {
        try
        {
            if (this.InvokeRequired)
                BeginInvoke(new Action(() =>
                {
                    if (BtnUp.BackgroundImage != null)
                        BtnUp.BackgroundImage.Dispose();
                    BtnUp.BackgroundImage = btnUp;
                    if (btnUp == null)
                        BtnUp.Text = m_strBtnUp;
                    else
                        BtnUp.Text = "";

                    if (BtnDn.BackgroundImage != null)
                        BtnDn.BackgroundImage.Dispose();
                    BtnDn.BackgroundImage = btnUp;
                    if (btnDn == null)
                        BtnDn.Text = m_strBtnDn;
                    else
                        BtnDn.Text = "";
                }));
            else
            {
                if (BtnUp.BackgroundImage != null)
                    BtnUp.BackgroundImage.Dispose();
                BtnUp.BackgroundImage = btnUp;
                if (btnUp == null)
                    BtnUp.Text = m_strBtnUp;
                else
                    BtnUp.Text = "";

                if (BtnDn.BackgroundImage != null)
                    BtnDn.BackgroundImage.Dispose();
                BtnDn.BackgroundImage = btnUp;
                if (btnDn == null)
                    BtnDn.Text = m_strBtnDn;
                else
                    BtnDn.Text = "";
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }

    /// <summary>
    /// 배경색 및 글자색 설정하기
    /// </summary>
    /// <param name="crBack">배경색</param>
    /// <param name="crFore">글자색</param>
    public void SetColor(Color crBack, Color crFore)
    {
        try
        {
            if (this.InvokeRequired)
                BeginInvoke(new Action(() =>
                {
                    this.BackColor = crBack;
                    this.ForeColor = crFore;
                    TxbValue.BackColor = crBack;
                    TxbValue.ForeColor = crFore;

                    if (BtnUp.BackgroundImage == null)
                    {
                        BtnUp.BackColor = crBack;
                        BtnUp.ForeColor = crFore;
                    }
                    if (BtnDn.BackgroundImage == null)
                    {
                        BtnDn.BackColor = crBack;
                        BtnDn.ForeColor = crFore;
                    }
                }));
            else
            {
                this.BackColor = crBack;
                this.ForeColor = crFore;
                TxbValue.BackColor = crBack;
                TxbValue.ForeColor = crFore;

                if (BtnUp.BackgroundImage == null)
                {
                    BtnUp.BackColor = crBack;
                    BtnUp.ForeColor = crFore;
                }
                if (BtnDn.BackgroundImage == null)
                {
                    BtnDn.BackColor = crBack;
                    BtnDn.ForeColor = crFore;
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }
    #endregion
}

2. 테스트 프로그램 실행 결과

[C#] DataGridView에서 콤보박스 컬럼을 사용하기

DevReff — Tue, 24 Jun 2025 23:09:17 +0900

1. DataGridView에 콤보박스 속성 추가하기

2. DataGridView의 속성 설정하기

3. DataGridView의 이벤트 추가하기

- 외부데이터 구문분석 또는 유효성검사 작업에서 예외를 throw하거나

데이터소스에 데이터를 커밋하려는 시도가 실패했을 발생하는 이벤트이다.

이 이벤트를 추가하지 않으면 각종 이벤트가 발생할 때마다 오류메시지가 표시되고 정상적으로 작동하지않는다.

grdData.DataError += new System.Windows.Forms.DataGridViewDataErrorEventHandler(grdData_DataError);

        private void grdData_DataError(object sender, DataGridViewDataErrorEventArgs e)
        {
            e.Cancel = true;
        }

- 콤보박스에 이벤트를 추가하거나 추가적인 작업을 하려면

CellBeginEdit 또는 CellEndEdit, EditingControlShowing 이벤트를 사용하면 된다.

CellBeginEdit : 콤보박스 셀에 대한 편집모드가 시작될 때 발생한다.
CellEndEdit : 콤보박스 셀에 대한 편집모드가 중지될 때 발생한다.
EditingControlShowing : 콤보박스 셀 편집을 위한 컨트롤이 표시될 때 발생한다.

예를들면 아래처럼 기능을 추가할 수 있다.

        private void grdData_EditingControlShowing(object sender, DataGridViewEditingControlShowingEventArgs e)
        {
            if (e.Control != null)
            {
                ComboBox comboBox = (ComboBox)e.Control;
                comboBox.SelectedIndexChanged -= Combo_SelectedIndexChanged;
                comboBox.SelectedIndexChanged += Combo_SelectedIndexChanged;
                Debug.WriteLine($"{comboBox.Items}");
            }
        }

콤보박스의 선택 항목이 변경되었을 때 추가작업을 할 수 있다.
        private void Combo_SelectedIndexChanged(object sender, EventArgs e)
        {

        }

4. DataGridView의 데이터소스에 데이터개체를 연동한 예제

    public class TestComboData
    {
        public string CD { get; set; } = "";
        public string NM { get; set; } = "";
        public string COR1 { get; set; } = "";
        public string COR2 { get; set; } = "";
        public string COR3 { get; set; } = "";

        public override string ToString()
        {
            return NM;
        }
    }

        List<TestComboData> dtCb = new List<TestComboData>();
private void Form2_Load(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;

            Random rd = new Random();

            for (int i = 0; i < 10; ++i)
            {
                int idx = rd.Next(1, 100);
                dtCb.Add(new TestComboData()
                {
                    CD=$"CD{idx}",
                    NM=$"NM{idx}",
                    COR1 = $"국어{idx}",
                    COR2 = $"수학{idx}",
                    COR3 = $"과학{idx}",
                });
            }
            var cbo = (DataGridViewComboBoxColumn)grdData.Columns["COMBO"];
            cbo.DisplayMember = "NM";
            cbo.ValueMember = "CD";
            cbo.DataSource = dtCb;

            List<TestData> dt = new List<TestData>();

            for (int i = 0; i < 10000; ++i)
            {
                int idx = rd.Next(0, 9);
                dt.Add(new TestData()
                {
                    CHK = rd.Next(1, 1000) % 2 == 0,
                    IDX = idx.ToString(),
                    NAME = $"NAME{idx}",
                    COMBO = dtCb[idx].CD,
                });
            }

            grdData.DataSource = dt;

Cursor.Current = Cursors.Default;
}

5. 결과물

[C#] ComboBox의 DataSource에 DataTable을 연결하여 사용하기

DevReff — Sun, 15 Jun 2025 17:45:24 +0900

1. 사용 예제

[그림1 콤보박스 화면에 표시될 속성명 지정하기

private void SetCbTest()
{
    Cursor.Current = Cursors.WaitCursor;

    var rd = new Random();
    var dt = new DataTable();
    var col = dt.Columns.Add("CHK");
    col = dt.Columns.Add("IDX");
    col = dt.Columns.Add("NM");
    for (int i = 0; i < 1000; ++i)
    {
        var row = dt.Rows.Add();
        row["CHK"] = rd.Next(1, 1000) % 2 == 0;
        row["IDX"] = i.ToString();
        row["NM"] = $"Name{i}";
    }
    cbTest.DataSource = dt;
    cbTest.DisplayMember = TxbDisplayMember.Text;

    Cursor.Current = Cursors.Default;
}

2. 컨트롤 소스
        /// <summary>
        /// 생성자
        /// </summary>
        public CjComboBox()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 현재 선택된 아이템 (형식:object[])
        /// </summary>
        public object[] SelectedObjects
        {
            get
            {
                if (this.SelectedIndex < 0)
                    return null;

                return this[this.SelectedIndex];
            }
        }

        /// <summary>
        /// Indexer 재정의하기
        /// </summary>
        /// <param name="i">인덱스 (zero-based)</param>
        /// <returns>배열</returns>
        public object[] this[int i]
        {
            get
            {
                try
                {
                    if (i < 0 || i >= this.Items.Count)
                        return null;

                    if (this.Items[i] == null || !(this.Items[i] is DataRowView))
                    {
                        return null;
                    }

                    return (this.Items[i] as DataRowView).Row.ItemArray;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"{this.Name} Error : {ex}");
                }

                return null;
            }
            set
            {
                try
                {
                    if (this.DataSource != null && this.DataSource is DataTable)
                    {
                        DataTable dt = this.DataSource as DataTable;
                        if (0 <= i && i < dt.Rows.Count)
                        {
                            dt.Rows[i].ItemArray = value;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"{this.Name} Error : {ex}");
                }
            }
        }

        /// <summary>
        /// Indexer 재정의하기
        /// </summary>
        /// <param name="i">인덱스 (zero-based)</param>
        /// <param name="fieldName">필드명</param>
        /// <returns>필드값</returns>
        public object this[int i, string fieldName]
        {
            get
            {
                try
                {
                    if (i < 0 || i >= this.Items.Count)
                        return null;

                    if (this.Items[i] == null || !(this.Items[i] is DataRowView))
                    {
                        Debug.WriteLine($"{this.Name}의 DataSource가 DataTable 형식이 아닙니다.");
                        return null;
                    }

                    DataRow dr = (this.Items[i] as DataRowView).Row;
                    if (dr.Table.Columns.Contains(fieldName))
                        return dr[fieldName];
                    else
                    {
                        Debug.WriteLine($"{this.Name}에는 {fieldName} 속성이 없습니다.");
                        return null;
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"{this.Name} Error : {ex}");
                }

                return null;
            }
        }
    }

[C#] DataGridView의 짝수행과 홀수행을 다르게 지정하는 방법

DevReff — Tue, 3 Jun 2025 08:05:37 +0900

1. 방법

DataGridView에서 짝수행과 홀수행의 배경색 및 글자색을 다르게 지정하는 방법은 의외로 간단하다.

DataGridView의 속성중에 AlternatingRowsDefaultCellStyle를 설정하면 된다.

이값을 설정하지 않으면 아래의 빨강색 사각영역과 같이 기본 형식으로 출력된다.

[그림1] DataGridView의 짝수행과 홀수행 배경색 및 글자색 지정하지 않았을 때

하지만 이 속성을 설정하면 아래와 같이 출력된다.

[그림2] DataGridView의 짝수행과 홀수행 배경색 및 글자색 지정했을 때

2. 예제 소스

using CjControls;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using Systehttp://m.Threading.Tasks;
using Systehttp://m.Windows.Forms;
using static Systehttp://m.Windows.Forms.VisualStyles.VisualStyleElement.Button;

namespace WindowsFormsApp5
{
    public partial class Form1 : Form
    {
        CjCalendars cjCalendars = new CjCalendars();
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            DataTable dt = new DataTable();
            var col = dt.Columns.Add("CHK");
            col = dt.Columns.Add("IDX");
            col = dt.Columns.Add("NAME");

            Random rd = new Random();
            for (int i = 0; i < 10000; ++i)
            {
                var row = dt.Rows.Add();
                row["CHK"] = rd.Next(1, 1000) % 2 == 0;
                row["IDX"] = i.ToString();
                row["NAME"] = $"Name{i}";
            }
            cjDataGridView1.SetDataSource(dt);
            cjDataGridView1.Dock= DockStyle.Fill;
            cjDataGridView1.DefaultCellStyle.BackColor = SystemColors.Control;
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            try
            {
                panel1.Controls.Add(cjCalendars);
                cjCalendars.SetMonth("20250531", "20250630", true);
                if (chkColorRow.Checked)
                {

//짝수행 색상을 지정하기
                    cjDataGridView1.AlternatingRowsDefaultCellStyle.BackColor = Color.Red;
                    cjDataGridView1.DefaultCellStyle.BackColor = Color.DarkGray; // 홀수행
                }
                else
                {

//짝수행 색상 지정을 해제하기
                    cjDataGridView1.AlternatingRowsDefaultCellStyle = null;
                    cjDataGridView1.DefaultCellStyle.BackColor = SystemColors.Control; // 모든행
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        private void cjDataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                if (e.ColumnIndex == 0)
                {
                    var grd = (sender as DataGridView);
                    var val = Convert.ToBoolean(grd.Rows[e.RowIndex].Cells[e.ColumnIndex].Value);
                    grd.Rows[e.RowIndex].Cells[e.ColumnIndex].Value = !val;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        private void chkColorRow_CheckedChanged(object sender, EventArgs e)
        {
            if (chkColorRow.Checked)

{

//짝수행 색상 지정을 해제하기
                    cjDataGridView1.AlternatingRowsDefaultCellStyle = null;
                    cjDataGridView1.DefaultCellStyle.BackColor = SystemColors.Control;  // 모든행
                }

}
}
}

[C#] DataGridView에서 DataSource 연동하는 방법

DevReff — Sat, 24 May 2025 19:12:54 +0900

1. 칼럼 생성 및 DataDouce와 연동되는 특성 설정하기

DataSource와 연동하기 위한 칼럼특성 설정 화면

DataSource에 연결할 때 사용되는 데이터의 컬럼명을 DataPropertyName에 입력한다.

예를들면 데이터베이스에서 로딩한 데이터를 DataTable로 수신했을 때

그 수신된 데이터그룹의 칼럼명을 DataPropertyName에 입력하면 된다.

2. 예제

Random rnd = new Random();
DataTable table = new DataTable();
   DataColumn col;
   col = table.Columns.Add("CHK", typeof(bool));
   col.ReadOnly = false;
   col = table.Columns.Add("NAME", typeof(string));
   col.ReadOnly = true;
   col = table.Columns.Add("AGE", typeof(int));
   col.ReadOnly = true;
   col = table.Columns.Add("SEX", typeof(string));
   col.ReadOnly = true;

   for (int i = 0; i < 100; ++i)
   {
       DataRow row = table.NewRow();
       row.ItemArray = new object[]
       {
           ((rnd.Next(1, 1000) % 2) == 0),
           $"Name{(i + 1)}",
           rnd.Next(1, 100),
           ((rnd.Next(1, 1000) % 2) == 0 ? "남" : "여")
       };
       table.Rows.Add(row);
   }
   grdView.DataSource = table;

빨강색 사각영역은 예제소스의 결과

위의 예제는 DataGridView의 칼럼 생성시 DataPropertyName을

첫번째 칼럼은 CHK, 이름은 NAME, 나이는 AGE, 성별은 SEX로 했고,

DataTable의 칼럼은 각각 CHK, NAME, AGE, SEX로 되어 있다.

[C#] 사용자 정의 달력

DevReff — Wed, 14 May 2025 00:06:53 +0900

1. 달력의 비어있는 날짜 컨트롤

2. 날짜 컨트롤

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Systehttp://m.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using Systehttp://m.Reflection.Emit;
using System.Text;
using Systehttp://m.Threading.Tasks;
using Systehttp://m.Windows.Forms;

namespace CjControls
{
    public partial class CjDay : UserControl
    {
        #region attributes
        /// <summary>
        /// 선택되었는지 여부
        /// </summary>
        private bool m_bSelected = false;
        [Browsable(true)]
        [Description("선택되었는지 여부")]
        [DefaultValue(false)]
        public bool Selected
        {
            get { return m_bSelected; }
            set
            {
                if (value)
                {
                    m_bSelected = true;
                    this.BackColor = this.m_selectedColor;
                    this.ForeColor = this.m_selectedTxtColor;
                }
                else
                {
                    m_bSelected = false;
                    m_nIndex = -1;
                    m_nMethod = -1;
                    this.BackColor = this.m_bkColor;
                    this.ForeColor = this.m_txtColor;
                }

                this.Invalidate();
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 존재여부
        /// </summary>
        private bool m_bOutline = false;
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 존재여부")]
        public bool Outline
        {
            get { return m_bOutline; }
            set
            {
                if (value != m_bOutline)
                {
                    m_bOutline = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택되지 않은 상태의 배경색
        /// </summary>
        private Color m_bkColor = SystemColors.Control;
        [Browsable(true)]
        [Description("선택되지 않은 상태의 배경색")]
        public Color BkColor
        {
            get { return m_bkColor; }
            set
            {
                if (value != m_bkColor)
                {
                    m_bkColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택된 상태의 배경색
        /// </summary>
        private Color m_selectedColor = SystemColors.ActiveCaption;
        [Browsable(true)]
        [Description("선택된 상태의 배경색")]
        public Color SelectedColor
        {
            get { return m_selectedColor; }
            set
            {
                if (value != m_selectedColor)
                {
                    m_selectedColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택되지 않은 상태의 글자색
        /// </summary>
        private Color m_txtColor = SystemColors.ControlText;
        [Browsable(true)]
        [Description("선택되지 않은 상태의 글자색")]
        public Color TxtColor
        {
            get { return m_txtColor; }
            set
            {
                if (value != m_txtColor)
                {
                    m_txtColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택된 상태의 글자색
        /// </summary>
        private Color m_selectedTxtColor = SystemColors.ControlText;
        [Browsable(true)]
        [Description("선택된 상태의 글자색")]
        public Color SelectedTxtColor
        {
            get { return m_selectedTxtColor; }
            set
            {
                if (value != m_selectedTxtColor)
                {
                    m_selectedTxtColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 색상
        /// </summary>
        private Color m_outlineColor = SystemColors.ButtonShadow;
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 색상")]
        public Color OutlineColor
        {
            get { return m_outlineColor; }
            set
            {
                if (value != m_outlineColor)
                {
                    m_outlineColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택된 날짜 그룹의 순번 (zero-based)
        /// - -1이면 선택되지 않음.
        /// - -1이 아니면 선택됨
        /// </summary>
        private int m_nIndex = -1;
        [Browsable(true)]
        [Description("선택된 날짜 그룹의 순번 (zero-based)")]
        [DefaultValue(-1)]
        public int Index
        {
            get { return m_nIndex; }
            set {  m_nIndex = value; }
        }

        /// <summary>
        /// 선택 유형 (default=0, 0=연속형, 1=단일형)
        /// </summary>
        /// <remarks>
        /// - 0 = 연속된 날짜로 구성된 그룹에 속함
        /// - 1 = 낱개로 구성된 날짜의 그룹에 속함
        /// </remarks>
        private int m_nMethod = -1;
        [Browsable(true)]
        [Description("선택 유형 (-1=선택안됨, 0=연속형, 1=단일형)")]
        [DefaultValue(-1)]
        public int Method
        {
            get { return m_nMethod; }
            set { m_nMethod = value; }
        }

        /// <summary>
        /// 년도 (1~9999)
        /// </summary>
        private int m_nYear = 0;
        [Browsable(true)]
        [Description("년도 (1~9999)")]
        [DefaultValue(0)]
        public int Year
        {
            get { return m_nYear; }
            set
            {
                m_nYear = value;

                if (m_nYear > 0 && m_nMonth > 0 && m_nDay > 0)
                {
                    m_Date = new DateTime(m_nYear, m_nMonth, m_nDay);
                    m_dateStr = $"{m_nYear.ToString("D4")}{m_nMonth.ToString("D2")}{m_nDay.ToString("D2")}";
                    WriteDay();
                }
            }
        }

        /// <summary>
        /// 월 (1~12)
        /// </summary>
        private int m_nMonth = 0;
        [Browsable(true)]
        [Description("월 (1~12)")]
        [DefaultValue(0)]
        public int Month
        {
            get { return m_nMonth; }
            set
            {
                m_nMonth = value;

                if (m_nYear > 0 && m_nMonth > 0 && m_nDay > 0)
                {
                    m_Date = new DateTime(m_nYear, m_nMonth, m_nDay);
                    m_dateStr = $"{m_nYear.ToString("D4")}{m_nMonth.ToString("D2")}{m_nDay.ToString("D2")}";
                    WriteDay();
                }
            }
        }

        /// <summary>
        /// 일 (1~31)
        /// </summary>
        private int m_nDay = 0;
        [Browsable(true)]
        [Description("일 (1~31)")]
        [DefaultValue(0)]
        public int Day
        {
            get { return m_nDay; }
            set
            {
                m_nDay = value;

                if (m_nYear > 0 && m_nMonth > 0 && m_nDay > 0)
                {
                    m_Date = new DateTime(m_nYear, m_nMonth, m_nDay);
                    m_dateStr = $"{m_nYear.ToString("D4")}{m_nMonth.ToString("D2")}{m_nDay.ToString("D2")}";

                    WriteDay();
                }
            }
        }

        /// <summary>
        /// 날짜
        /// </summary>
        private DateTime m_Date = DateTime.MinValue;
        [Browsable(true)]
        [Description("날짜")]
        [DefaultValue(0)]
        public DateTime Date
        {
            get { return m_Date; }
            set
            {
                try
                {
                    if (value != DateTime.MinValue && value != DateTime.MaxValue)
                    {
                        Year = value.Year;
                        Month = value.Month;
                        Day = value.Day;
                        m_Date = value;
                        m_dateStr = $"{m_nYear.ToString("D4")}{m_nMonth.ToString("D2")}{m_nDay.ToString("D2")}";
                        WriteDay();
                    }
                    else
                        m_Date = DateTime.MinValue;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.Message);
                }
            }
        }

        /// <summary>
        /// 날짜 문자열 (yyyyMMdd)
        /// </summary>
        private string m_dateStr = "";
        [Browsable(true)]
        [Description("날짜 문자열 (yyyyMMdd)")]
        [DefaultValue(0)]
        public string DateStr
        {
            get { return m_dateStr; }
            set
            {
                if (!string.IsNullOrWhiteSpace(value) && value.Length >= 8
                    && DateTime.TryParseExact(value, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime dt))
                {
                    m_dateStr = value;
                    m_Date = dt;
                    m_nYear = dt.Year;
                    m_nMonth = dt.Month;
                    m_nDay = dt.Day;
                    WriteDay();
                }
                else
                {
                    Debug.WriteLine($"잘못된 날짜({value})를 DateStr에 대입했습니다.");
                }
            }
        }
        #endregion

        #region 생성자
        /// <summary>
        /// 생성자
        /// </summary>
        public CjDay()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="day">일 (1~31)</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽선의 존재여부</param>
        public CjDay(int year, int month, int day, bool selected = false, bool bOutline = false)
        {
            InitializeComponent();

            Initialize(year, month, day, selected, bOutline);
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="dt">날짜</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽선의 존재여부</param>
        public CjDay(DateTime dt, bool selected = false, bool bOutline = false)
        {
            InitializeComponent();

            Initialize(dt, selected, bOutline);
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="dtStr">날짜</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽선의 존재여부</param>
        public CjDay(string dtStr, bool selected = false, bool bOutline = false)
        {
            InitializeComponent();

            Initialize(dtStr, selected, bOutline);
        }
        #endregion

        #region 컨트롤 이벤트
        /// <summary>
        /// WM_PAINT 메시지 이벤트
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            if (m_bOutline)
                ControlPaint.DrawBorder(e.Graphics, ClientRectangle, m_outlineColor, ButtonBorderStyle.Solid);

            if (m_bSelected)
            {
                LblDay.BackColor = m_selectedColor;
                LblDay.ForeColor = m_selectedTxtColor;
            }
            else
            {
                LblDay.BackColor = m_bkColor;
                LblDay.ForeColor = m_txtColor;
            }
            //using (Graphics g = e.Graphics)
            //{
            //    Brush bs = new SolidBrush(m_bSelected ? m_selectedColor : m_bkColor);
            //    Rectangle rc = ClientRectangle;
            //    g.FillRectangle(bs, rc);

            //    g.DrawString(DateStr, this.Font, bs, rc);
            //}
        }
        #endregion

        #region 외부 함수
        /// <summary>
        /// 날짜 초기화하기
        /// </summary>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="day">일 (1~31)</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽선의 존재여부</param>
        /// <returns>성공여부</returns>
        public bool Initialize(int year, int month, int day, bool selected = false, bool bOutline = false)
        {
            m_bSelected = selected;
            m_bOutline = bOutline;

            if (0 < year && year < DateTime.MaxValue.Year
                && 0 < month && month < 12
                && 0 < day && day < DateTime.DaysInMonth(year, month))
            {
                m_Date = new DateTime(year, month, day);
                return true;
            }

            Debug.WriteLine($"잘못된 날짜 매개변수({year}년, {month}월 {day}일) 입니다.");
            return false;
        }

        /// <summary>
        /// 날짜 초기화하기
        /// </summary>
        /// <param name="dt">날짜</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public bool Initialize(DateTime dt, bool selected = false, bool bOutline = false)
        {
            m_bSelected = selected;
            m_bOutline = bOutline;

            if (dt != DateTime.MaxValue && dt != DateTime.MinValue)
            {
                m_Date = dt;
                return true;
            }

            Debug.WriteLine($"잘못된 날짜 매개변수({dt}) 입니다.");
            return false;
        }

        /// <summary>
        /// 날짜 초기화하기
        /// </summary>
        /// <param name="dtStr">날짜 (yyyyMMdd)</param>
        /// <param name="selected">선택되었는지 여부 (default=false)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public bool Initialize(string dtStr, bool selected = false, bool bOutline = false)
        {
            m_bSelected = selected;
            m_bOutline = bOutline;

            if (!string.IsNullOrWhiteSpace(dtStr) && dtStr.Length >= 8
                && DateTime.TryParseExact(dtStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime dt))
            {
                m_Date = dt;
                return true;
            }

            Debug.WriteLine($"잘못된 날짜 매개변수({dtStr}) 입니다.");
            return false;
        }

        /// <summary>
        /// 날짜에 일수 더하기
        /// </summary>
        /// <param name="days">일수</param>
        public CjDay AddDays(int days)
        {
            if (this.Date != DateTime.MinValue && this.Date != DateTime.MaxValue)
                return new CjDay(this.Date.AddDays(days));
            return this;
        }

        /// <summary>
        /// 날짜에 월수 더하기
        /// </summary>
        /// <param name="months">월수</param>
        public CjDay AddMonths(int months)
        {
            if (this.Date != DateTime.MinValue && this.Date != DateTime.MaxValue)
                return new CjDay(this.Date.AddMonths(months));
            return this;
        }

        /// <summary>
        /// 날짜에 년수 더하기
        /// </summary>
        /// <param name="years">년수</param>
        public CjDay AddYears(int years)
        {
            if (this.Date != DateTime.MinValue && this.Date != DateTime.MaxValue)
                return new CjDay(this.Date.AddYears(years));
            return this;
        }

        /// <summary>
        /// 날짜를 컨트롤에 출력한다.
        /// </summary>
        public void WriteDay()
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new EventHandler(delegate
                {
                    LblDay.Text = m_nDay.ToString("D2");
                }));
            }
            else
                LblDay.Text = m_nDay.ToString("D2");
        }
        #endregion
    }
}

3. 요일 표시 컨트롤

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using Systehttp://m.Threading.Tasks;
using Systehttp://m.Windows.Forms;

namespace CjControls
{
    /// <summary>
    /// 요일을 표시하는 컨트롤
    /// </summary>
    public partial class CjWeek : UserControl
    {
        #region attributes
        /// <summary>
        /// 요일 (0=일, 1=월, ..., 6=토)
        /// </summary>
        private DayOfWeek m_nWeek;
        [Browsable(true)]
        [Description("요일 (0=일, 1=월, ..., 6=토)")]
        public DayOfWeek Week
        {
            get { return m_nWeek; }
            set
            {
                if (DayOfWeek.Sunday <= value && value <= DayOfWeek.Saturday)
                    m_nWeek = value;

                if (this.InvokeRequired)
                {
                    this.Invoke(new EventHandler(delegate
                    {
                        LblWeek.Text = WeekStr;
                    }));
                }
                else
                    LblWeek.Text = WeekStr;
            }
        }

        /// <summary>
        /// 요일 문자열
        /// </summary>
        [Browsable(true)]
        [Description("요일 (0=일, 1=월, ..., 6=토)")]
        public string WeekStr
        {
            get
            {
                if (m_nWeek == DayOfWeek.Monday)
                    return "월";
                else if (m_nWeek == DayOfWeek.Tuesday)
                    return "화";
                else if (m_nWeek == DayOfWeek.Wednesday)
                    return "수";
                else if (m_nWeek == DayOfWeek.Thursday)
                    return "목";
                else if (m_nWeek == DayOfWeek.Friday)
                    return "금";
                else if (m_nWeek == DayOfWeek.Saturday)
                    return "토";
                else if (m_nWeek == DayOfWeek.Sunday)
                    return "일";
                else
                    return "";
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 존재여부
        /// </summary>
        private bool m_bOutline = false;
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 존재여부")]
        public bool Outline
        {
            get { return m_bOutline; }
            set
            {
                if (value != m_bOutline)
                {
                    m_bOutline = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 색상
        /// </summary>
        private Color m_outlineColor = SystemColors.ButtonShadow;
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 색상")]
        public Color OutlineColor
        {
            get { return m_outlineColor; }
            set
            {
                if (value != m_outlineColor)
                {
                    m_outlineColor = value;
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// 선택되지 않은 상태의 배경색
        /// </summary>
        private Color m_bkColor = SystemColors.Control;
        [Browsable(true)]
        [Description("선택되지 않은 상태의 배경색")]
        public Color BkColor
        {
            get { return m_bkColor; }
            set
            {
                if (value != m_bkColor)
                {
                    m_bkColor = value;

                    if (this.InvokeRequired)
                    {
                        this.Invoke(new EventHandler(delegate
                        {
                            LblWeek.BackColor = m_bkColor;
                        }));
                    }
                    else
                        LblWeek.BackColor = m_bkColor;
                }
            }
        }

        /// <summary>
        /// 선택되지 않은 상태의 글자색
        /// </summary>
        private Color m_txtColor = SystemColors.ControlText;
        [Browsable(true)]
        [Description("선택되지 않은 상태의 글자색")]
        public Color TxtColor
        {
            get { return m_txtColor; }
            set
            {
                if (value != m_txtColor)
                {
                    m_txtColor = value;

                    if (this.InvokeRequired)
                    {
                        this.Invoke(new EventHandler(delegate
                        {
                            LblWeek.ForeColor = m_txtColor;
                        }));
                    }
                    else
                        LblWeek.ForeColor = m_txtColor;
                }
            }
        }
        #endregion

        #region 생성자
        /// <summary>
        /// 생성자
        /// </summary>
        public CjWeek()
        {
            InitializeComponent();

            Week = DayOfWeek.Sunday;
        }
        #endregion

        #region 컨트롤 이벤트
        /// <summary>
        /// WM_PAINT 메시지 이벤트
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            if (m_bOutline)
                ControlPaint.DrawBorder(e.Graphics, ClientRectangle, m_outlineColor, ButtonBorderStyle.Solid);

        }
        #endregion

    }
}

4. 달력

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Systehttp://m.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using Systehttp://m.Threading.Tasks;
using Systehttp://m.Windows.Forms;

namespace CjControls
{
    /// <summary>
    /// 단일 달력 컨트롤
    /// </summary>
    //[Designer("Systehttp://m.Windows.Forms.Design.ParentControlDesigner, System.Design", typeof(IDesigner))]
    public partial class CjCalendarUnit : UserControl
    {
        #region attributes
        /// <summary>
        /// 달력 순번 (zero-based)
        /// </summary>
        private int m_nIndex = 0;
        [Category("CjCalendarUnit")]
        [Browsable(false)]
        [Description("달력 순번")]
        public int Index
        {
            get { return m_nIndex; }
            set
            {
                m_nIndex = value;
            }
        }

        /// <summary>
        /// 달력이 위치한 행번호 (zero-based)
        /// </summary>
        private int m_nRow = 0;
        [Category("CjCalendarUnit")]
        [Browsable(false)]
        [Description("달력이 위치한 행번호")]
        public int Row
        {
            get { return m_nRow; }
            set
            {
                m_nRow = value;
            }
        }

        /// <summary>
        /// 달력이 위치한 열번호 (zero-based)
        /// </summary>
        private int m_nColumn = 0;
        [Category("CjCalendarUnit")]
        [Browsable(false)]
        [Description("달력이 위치한 열번호")]
        public int Column
        {
            get { return m_nColumn; }
            set
            {
                m_nColumn = value;
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 존재여부
        /// </summary>
        private bool m_bOutline = true;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 존재여부")]
        public bool Outline
        {
            get { return m_bOutline; }
            set
            {
                m_bOutline = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 색상
        /// </summary>
        private Color m_outlineColor = SystemColors.ButtonShadow;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("선택된 상태의 글자색")]
        public Color OutlineColor
        {
            get { return m_outlineColor; }
            set
            {
                m_outlineColor = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 날짜와 날짜 사이의 가로 간격 (default=0)
        /// </summary>
        private int m_xSpace = 0;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("날짜와 날짜 사이의 가로 간격")]
        public int XSpace
        {
            get { return (int)m_xSpace; }
            set
            {
                m_xSpace = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 날짜와 날짜 사이의 세로 간격 (default=0)
        /// </summary>
        private int m_ySpace = 0;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("날짜와 날짜 사이의 세로 간격")]
        public int YSpace
        {
            get { return (int)m_ySpace; }
            set
            {
                m_ySpace = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 현재 년도 (1~9999)
        /// </summary>
        private int m_nYear = DateTime.Now.Year;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("년도 (1~9999)")]
        public int Year
        {
            get { return m_nYear; }
            set
            {
                m_nYear = value;

                if (m_nYear > 0 && m_nMonth > 0)
                {
                    m_strMonth = string.Format("{0:D4}{1:D2}", m_nYear, m_nMonth);
                }
            }
        }

        /// <summary>
        /// 현재 월 (1~12)
        /// </summary>
        private int m_nMonth = DateTime.Now.Month;
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("월 (1~12)")]
        public int Month
        {
            get { return m_nMonth; }
            set
            {
                m_nMonth = value;

                if (m_nYear > 0 && m_nMonth > 0)
                {
                    m_strMonth = string.Format("{0:D4}{1:D2}", m_nYear, m_nMonth);
                }
            }
        }

        /// <summary>
        /// 현재 달력의 년월 (yyyyMM)
        /// </summary>
        private string m_strMonth = DateTime.Now.ToString("yyyyMM");
        [Category("CjCalendarUnit")]
        [Browsable(true)]
        [Description("달력의 년월 (yyyyMM)")]
        public string MonthString
        {
            get
            {
                if (string.IsNullOrWhiteSpace(m_strMonth))
                    return DateTime.Now.ToString("yyyyMM");
                else
                    return m_strMonth;
            }
            set
            {
                if (!string.IsNullOrWhiteSpace(value) && value.Length >= 6
                    && DateTime.TryParseExact(value.Substring(0, 6) + "01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime dt))
                {
                    Year = dt.Year;
                    Month = dt.Month;
                    m_strMonth = value;
                }
                else
                    Debug.WriteLine($"잘못된 년월({value})을 MonthString에 대입했습니다.");
            }
        }

        /// <summary>
        /// 달력 생성에 성공했는지 여부
        /// </summary>
        public bool m_bSuccessed = false;
        [Category("CjCalendarUnit")]
        [Browsable(false)]
        [Description("달력 생성에 성공했는지 여부")]
        public bool Successed { get { return m_bSuccessed; } }
        #endregion

        #region 생성자
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="index">달력 순번 (zero-based)</param>
        /// <remarks>달력생성에 실패하면 순번은 0이 됨</remarks>
        public CjCalendarUnit(int index = 0)
        {
            InitializeComponent();

            if (Initialize(DateTime.Now.Year, DateTime.Now.Month))
                if (Create(Year, Month))
                {
                    m_nIndex = index;
                    m_bSuccessed = true;
                }
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="index">달력 순번 (zero-based)</param>
        /// <param name="dtStr">년월 (yyyyMM)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <remarks>달력생성에 실패하면 순번은 0이 됨</remarks>
        public CjCalendarUnit(int index, string dtStr, bool bOutline = false)
        {
            InitializeComponent();

            if (Initialize(dtStr, bOutline))
                if (Create(Year, Month))
                {
                    m_nIndex = index;
                    m_bSuccessed = true;
                }
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="index">달력 순번 (zero-based)</param>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <remarks>달력생성에 실패하면 순번은 0이 됨</remarks>
        public CjCalendarUnit(int index, int year, int month, bool bOutline = false)
        {
            InitializeComponent();

            m_bSuccessed = Initialize(year, month, bOutline);
            m_bSuccessed |= Create(Year, Month);

            if (m_bSuccessed)
                m_nIndex = index;
        }
        #endregion

        #region 컨트롤 이벤트
        /// <summary>
        /// WM_PAINT 메시지 이벤트
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            if (m_bOutline)
                ControlPaint.DrawBorder(e.Graphics, ClientRectangle, m_outlineColor, ButtonBorderStyle.Solid);

            //using (Graphics g = e.Graphics)
            //{
            //    if (SelectionDates != null && SelectionDates.Count > 0)
            //        foreach (CjSelectionDates v in SelectionDates)
            //        {
            //            if (v.Method == 1)
            //            {
            //                if (v.Days != null && v.Days.Count > 0)
            //                    foreach (CjDay vv in v.Days)
            //                    {
            //                        vv.Selected = true;
            //                    }
            //            }
            //            else
            //            {
            //                //CjDay st = v.Start <= v.End ? v.Start : v.End;
            //                //CjDay et = v.Start <= v.End ? v.End : v.Start;
            //                //for (; st <= et; st = st.AddDays(1))
            //                //{
            //                //    st.Selected = true;
            //                //}
            //            }
            //        }
            //}
        }
        #endregion

        #region 외부 함수
        /// <summary>
        /// 달력 초기화하기
        /// </summary>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public bool Initialize(int year, int month, bool bOutline = false)
        {
            m_bOutline = bOutline;

            if (0 < year && year < DateTime.MaxValue.Year
                && 0 < month && month < 12
                && DateTime.TryParseExact($"{year.ToString("D4")}{month.ToString("D2")}01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime dt))
            {
                m_nYear = year;
                m_nMonth = month;
                m_strMonth = $"{year.ToString("D4")}{month.ToString("D2")}";
                return true;
            }

            Debug.WriteLine($"잘못된 날짜 매개변수({year}년, {month}월) 입니다.");
            return false;
        }

        /// <summary>
        /// 달력 초기화하기
        /// </summary>
        /// <param name="dtStr">년월 (yyyyMM)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public bool Initialize(string dtStr, bool bOutline = false)
        {
            m_bOutline = bOutline;

            DateTime dt;
            if ((dtStr.Length >= 8 && DateTime.TryParseExact(dtStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt))
                || (dtStr.Length >= 6 && DateTime.TryParseExact(dtStr.Substring(0, 6) + "01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt)))
            {
                m_nYear = dt.Year;
                m_nMonth = dt.Month;
                m_strMonth = dt.ToString("yyyyMM");
                return true;
            }

            Debug.WriteLine($"잘못된 년월 매개변수({dtStr}) 입니다.");
            return false;
        }

        /// <summary>
        /// 달력 생성하기
        /// </summary>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public bool Create(int year, int month, bool bOutline = false)
        {
            try
            {
                PnlBody.Controls.Clear();

                return Create($"{year.ToString("D4")}{month.ToString("D2")}", bOutline);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            return false;
        }

        /// <summary>
        /// 달력 생성하기
        /// </summary>
        /// <param name="dateStr">생성할 달력의 년월(yyyyMM 또는 yyyyMMdd)</param>
        /// <param name="bOutline">외관경계선의 존재 여부</param>
        /// <returns>성공여부</returns>
        public bool Create(string dateStr, bool bOutline = false)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(dateStr) || dateStr.Length < 6)
                    return false;

                DateTime dt;
                if ((dateStr.Length >= 8 && !DateTime.TryParseExact(dateStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt))
                    || !DateTime.TryParseExact(dateStr.Substring(0, 6) + "01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt))
                {
                    Debug.WriteLine($"달력생성 오류: 잘못된 날짜 매개변수 ({dateStr})");
                    return false;
                }

                Size daySize = new Size(40, 20);
                int wi = 0, hi = 0;
                int x = 0;
                int y = 0;
                int tabIndex = 0;
                int day = 1;
                int c, r = 0;
                dt = new DateTime(m_nYear, m_nMonth, day);

                m_nYear = dt.Year;
                m_nMonth = dt.Month;
                m_strMonth = dt.ToString("yyyyMM");

                #region 년월 출력
                if (this.InvokeRequired)
                {
                    this.Invoke(new EventHandler(delegate
                    {
                        LblTitle.Text = string.Format("{0:D4}년 {1:D2}월", m_nYear, m_nMonth);
                    }));
                }
                else
                    LblTitle.Text = string.Format("{0:D4}년 {1:D2}월", m_nYear, m_nMonth);

                hi += LblTitle.Height;
                #endregion

                #region 요일 출력
                for (c = 0; c < 7; ++c)
                {
                    CjWeek cjWeek = new CjWeek();
                    cjWeek.BkColor = System.Drawing.SystemColors.Control;
                    cjWeek.Font = new Systehttp://m.Drawing.Font("바탕체", 10F, System.Drawing.FontStyle.Regular, Systehttp://m.Drawing.GraphicsUnit.Point, ((byte)(129)));
                    cjWeek.Location = new Systehttp://m.Drawing.Point(x, y);
                    cjWeek.MinimumSize = daySize;
                    cjWeek.Name = string.Format("cjWeek{0:D2}", c + 1);
                    cjWeek.Outline = false;
                    cjWeek.OutlineColor = System.Drawing.SystemColors.ButtonShadow;
                    cjWeek.Size = daySize;
                    cjWeek.TabIndex = tabIndex;
                    cjWeek.TxtColor = System.Drawing.SystemColors.ControlText;
                    cjWeek.Week = (System.DayOfWeek)c;

                    cjWeek.Click += OnClickWeeks;
                    PnlBody.Controls.Add(cjWeek);
                    x += daySize.Width;
                }

                y += daySize.Height;
                #endregion

                #region 빈 날짜 출력
                for (c = 0, x = 0; c < (int)dt.DayOfWeek; ++c)
                {
                    CjBlank cjBlank = new CjBlank();
                    cjBlank.Font = new Systehttp://m.Drawing.Font("바탕체", 10F, System.Drawing.FontStyle.Regular, Systehttp://m.Drawing.GraphicsUnit.Point, ((byte)(129)));
                    cjBlank.Location = new Systehttp://m.Drawing.Point(x, y);
                    cjBlank.Margin = new Systehttp://m.Windows.Forms.Padding(4, 3, 4, 3);
                    cjBlank.MinimumSize = daySize;
                    cjBlank.Name = string.Format("cjBlank{0:D2}", c + 1);
                    cjBlank.Size = daySize;
                    cjBlank.TabIndex = ++tabIndex;

                    PnlBody.Controls.Add(cjBlank);
                    x += daySize.Width;
                }
                #endregion

                #region 날짜 출력
                for (int days = DateTime.DaysInMonth(m_nYear, m_nMonth); day <= days; )
                {
                    for ( ; c < 7 && day <= days; ++c, ++day)
                    {
                        dt = new DateTime(m_nYear, m_nMonth, day);
                        CjDay cjDay = new CjDay();
                        cjDay.BackgroundImageLayout = Systehttp://m.Windows.Forms.ImageLayout.Stretch;
                        cjDay.BkColor = System.Drawing.SystemColors.Control;
                        cjDay.CausesValidation = false;
                        cjDay.DateStr = dt.ToString("yyyyMMdd");
                        cjDay.Font = new Systehttp://m.Drawing.Font("바탕체", 10F);
                        cjDay.Location = new Systehttp://m.Drawing.Point(x, y);
                        cjDay.MinimumSize = daySize;
                        cjDay.Name = string.Format("cjDay{0:D2}", dt.Day);
                        cjDay.Outline = false;
                        cjDay.OutlineColor = System.Drawing.SystemColors.ButtonShadow;
                        cjDay.SelectedColor = System.Drawing.SystemColors.ActiveCaption;
                        cjDay.SelectedTxtColor = System.Drawing.SystemColors.ControlText;
                        cjDay.Size = daySize;
                        cjDay.TabIndex = ++tabIndex;
                        cjDay.TxtColor = System.Drawing.SystemColors.ControlText;

                        cjDay.Click += OnClickDays;
                        PnlBody.Controls.Add(cjDay);

                        x += daySize.Width;
                        if (wi < x)
                            wi = x;
                    }

                    ++r;
                    c = 0;
                    x = 0;
                    y += daySize.Height;
                }
                #endregion

                hi += ((r < 6)? y + daySize.Height : y) + SystemInformation.FrameBorderSize.Height;
                wi += SystemInformation.FrameBorderSize.Width;
                this.Size = new Systehttp://m.Drawing.Size(wi, hi);
                this.MinimumSize = this.Size;

                return true;
            }
            catch (Exception ex)
            {
                Debug.WriteLine (ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 날짜를 클릭했을 때
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void OnClickDays(object sender, EventArgs e)
        {
            try
            {
                Debug.WriteLine($"{sender.ToString()}");
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// 요일을 클릭했을 때
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void OnClickWeeks(object sender, EventArgs e)
        {
            try
            {
                Debug.WriteLine($"{sender.ToString()}");
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }
        #endregion
    }
}

5. 다중 달력

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using Systehttp://m.Threading.Tasks;
using Systehttp://m.Windows.Forms;
using static Systehttp://m.Windows.Forms.VisualStyles.VisualStyleElement.Tab;

namespace CjControls
{
    public partial class CjCalendars : UserControl
    {
        #region attributes
        /// <summary>
        /// 컨트롤의 외곽라인의 존재여부
        /// </summary>
        private bool m_bOutline = true;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("컨트롤의 외곽라인의 존재여부")]
        public bool Outline
        {
            get { return m_bOutline; }
            set
            {
                m_bOutline = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 컨트롤의 외곽라인의 색상
        /// </summary>
        private Color m_outlineColor = SystemColors.ButtonShadow;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("선택된 상태의 글자색")]
        public Color OutlineColor
        {
            get { return m_outlineColor; }
            set
            {
                m_outlineColor = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 날짜와 날짜 사이의 가로 간격 (default=0)
        /// </summary>
        private int m_xSpace = 0;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("날짜와 날짜 사이의 가로 간격")]
        public int XSpace
        {
            get { return (int)m_xSpace; }
            set
            {
                m_xSpace = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 날짜와 날짜 사이의 세로 간격 (default=0)
        /// </summary>
        private int m_ySpace = 0;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("날짜와 날짜 사이의 세로 간격")]
        public int YSpace
        {
            get { return (int)m_ySpace; }
            set
            {
                m_ySpace = value;
                this.Invalidate();
            }
        }

        /// <summary>
        /// 현재 년도 (1~9999)
        /// </summary>
        private int m_nYear = DateTime.Now.Year;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("년도 (1~9999)")]
        public int Year
        {
            get { return m_nYear; }
            set
            {
                m_nYear = value;

                if (m_nYear > 0 && m_nMonth > 0)
                {
                    m_strMonth = string.Format("{0:D4}{1:D2}", m_nYear, m_nMonth);
                }
            }
        }

        /// <summary>
        /// 현재 월 (1~12)
        /// </summary>
        private int m_nMonth = DateTime.Now.Month;
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("월 (1~12)")]
        public int Month
        {
            get { return m_nMonth; }
            set
            {
                m_nMonth = value;

                if (m_nYear > 0 && m_nMonth > 0)
                {
                    m_strMonth = string.Format("{0:D4}{1:D2}", m_nYear, m_nMonth);
                }
            }
        }

        /// <summary>
        /// 현재 달력의 년월 (yyyyMM)
        /// </summary>
        private string m_strMonth = DateTime.Now.ToString("yyyyMM");
        [Category("CjCalendars")]
        [Browsable(true)]
        [Description("달력의 년월 (yyyyMM)")]
        public string MonthString
        {
            get
            {
                if (string.IsNullOrWhiteSpace(m_strMonth))
                    return DateTime.Now.ToString("yyyyMM");
                else
                    return m_strMonth;
            }
            set
            {
                if (!string.IsNullOrWhiteSpace(value) && value.Length >= 6
                    && DateTime.TryParseExact(value.Substring(0, 6) + "01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime dt))
                {
                    Year = dt.Year;
                    Month = dt.Month;
                    m_strMonth = value;
                }
                else
                    Debug.WriteLine($"잘못된 년월({value})을 MonthString에 대입했습니다.");
            }
        }

        /// <summary>
        /// 선택된 날짜 목록
        /// </summary>
        private List<CjSelectionDates> m_SelectionDates = new List<CjSelectionDates>();
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("선택된 날짜 목록")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public List<CjSelectionDates> SelectionDates
        {
            get
            {
                return m_SelectionDates;
            }
            set
            {
                if (value == null)
                    m_SelectionDates = new List<CjSelectionDates>();
                else
                    m_SelectionDates = value;
            }
        }

        /// <summary>
        /// 선택된 날짜들로 화면에 표시해야할 달력(yyyyMM)들
        /// </summary>
        public List<string> MonthList
        {
            get
            {
                if (SelectionDates == null || SelectionDates.Count < 1)
                    return new List<string>();
                else
                {
                    List<string> list = new List<string>();

                    foreach (CjSelectionDates v in SelectionDates)
                    {
                        if (v.Method == 1)
                        {
                            list.AddRange((from CjDay vv in v.Days
                                           let month = vv.Date.ToString("yyyyMM")
                                           where !list.Contains(month)
                                           orderby vv.Date
                                           select month).Distinct().ToList());
                        }
                        else
                        {
                            for (DateTime st = v.Start.Date; st <= v.End.Date; st = st.AddMonths(1))
                            {
                                string month = st.ToString("yyyyMM");
                                if (!list.Contains(month))
                                    list.Add(month);
                            }
                        }
                    }

                    return list.Distinct().ToList();
                }
            }
        }

        /// <summary>
        /// 단위달력의 최소 폭
        /// </summary>
        private const int MinWidth = 292;
        /// <summary>
        /// 단위달력의 최소 높이
        /// </summary>
        private const int MinHight = 188;

        /// <summary>
        /// 단위달력의 폭
        /// </summary>
        private int m_nUnitWidth = 0;
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("단위달력의 폭")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int UnitWidth
        {
            get { return m_nUnitWidth; }
            set
            {
                m_nUnitWidth = value;
            }
        }

        /// <summary>
        /// 단위달력의 높이
        /// </summary>
        private int m_nUnitHeight = 0;
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("단위달력의 높이")]
        public int UnitHeight
        {
            get { return m_nUnitHeight; }
            set
            {
                m_nUnitHeight = value;
            }
        }

        /// <summary>
        /// 행 갯수
        /// </summary>
        private int m_nRowCount = 1;
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("행 갯수")]
        public int RowCount
        {
            get { return m_nRowCount; }
            set
            {
                m_nRowCount = value;
            }
        }

        /// <summary>
        /// 열 갯수
        /// </summary>
        private int m_nColCount = 1;
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("열 갯수")]
        public int ColCount
        {
            get { return m_nColCount; }
            set
            {
                m_nColCount = value;
            }
        }

        /// <summary>
        /// 수정되었는지 여부
        /// </summary>
        private bool m_bMofidied = false;
        [Category("CjCalendars")]
        [Browsable(false)]
        [Description("수정되었는지 여부")]
        public bool IsModified
        {
            get { return m_bMofidied; }
            set
            {
                m_bMofidied = value;

                if (m_bMofidied)
                {
                    Create(m_bOutline);
                }
            }
        }
        #endregion

        #region 생성자
        /// <summary>
        /// 생성자
        /// </summary>
        public CjCalendars()
        {
            InitializeComponent();

            try
            {
                if (this.DesignMode)
                    Create();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="dtStr">년월 (yyyyMM)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        public CjCalendars(List<CjSelectionDates> cjSelections, bool bOutline = false)
        {
            InitializeComponent();

            try
            {
                if (cjSelections != null && cjSelections.Count > 0)
                    SelectionDates = cjSelections;

                if (this.DesignMode)
                    Create();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }
        #endregion

        #region 컨트롤 이벤트
        /// <summary>
        /// WM_PAINT 메시지 이벤트
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            if (m_bOutline)
                ControlPaint.DrawBorder(e.Graphics, ClientRectangle, m_outlineColor, ButtonBorderStyle.Solid);

            //using (Graphics g = e.Graphics)
            //{
            //    if (SelectionDates != null && SelectionDates.Count > 0)
            //        foreach (CjSelectionDates v in SelectionDates)
            //        {
            //            if (v.Method == 1)
            //            {
            //                if (v.Days != null && v.Days.Count > 0)
            //                    foreach (CjDay vv in v.Days)
            //                    {
            //                        vv.Selected = true;
            //                    }
            //            }
            //            else
            //            {
            //                //CjDay st = v.Start <= v.End ? v.Start : v.End;
            //                //CjDay et = v.Start <= v.End ? v.End : v.Start;
            //                //for (; st <= et; st = st.AddDays(1))
            //                //{
            //                //    st.Selected = true;
            //                //}
            //            }
            //        }
            //}
        }
        #endregion

        #region 내부함수
        /// <summary>
        /// 달력 행렬 설정하기
        /// </summary>
        private void SetLayoutCalendar()
        {
            #region 행렬 생성
            if (this.MonthList.Count > 9)
            {
                m_nRowCount = 3;
                m_nColCount = 4;
            }
            else if (this.MonthList.Count > 6)
            {
                m_nRowCount = 3;
                m_nColCount = 3;
            }
            else if (this.MonthList.Count > 4)
            {
                m_nRowCount = 2;
                m_nColCount = 3;
            }
            else if (this.MonthList.Count == 4)
            {
                m_nRowCount = 2;
                m_nColCount = 2;
            }
            else if (this.MonthList.Count == 3)
            {
                m_nRowCount = 1;
                m_nColCount = 3;
            }
            else if (this.MonthList.Count == 2)
            {
                m_nRowCount = 1;
                m_nColCount = 2;
            }
            else
            {
                m_nRowCount = 1;
                m_nColCount = 1;
            }
            #endregion

        }
        #endregion

        #region 외부 함수
        /// <summary>
        /// 달력 생성하기
        /// </summary>
        /// <param name="bOutline">달력의 외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>생성된 달력의 갯수</returns>
        public int Create(bool bOutline = false)
        {
            int countCalendars = 0;

            try
            {
                SetLayoutCalendar();

                int wi = MinWidth, hi = MinHight;

                if (this.MonthList.Count > 0)
                {
                    int idx = -1;
                    for (int r = 0; r < m_nRowCount; ++r)
                    {
                        for (int c = 0; c < m_nColCount; ++c)
                        {
                            ++idx;

                            if (idx < this.MonthList.Count)
                            {
                                string v = this.MonthList[idx].ToString();
                                int year = Convert.ToInt32(v.Substring(0, 4));
                                int month = Convert.ToInt32(v.Substring(4, 2));
                                var unit = Create(idx, v, bOutline);
                                if (unit != null)
                                {
                                    unit.Row = r;
                                    unit.Column = c;
                                    tblCalendars.Controls.Add(unit, c, r);

                                    if (wi < unit.Width)
                                        wi = unit.Width;
                                    if (hi < unit.Height)
                                        hi = unit.Height;

                                    ++countCalendars;
                                }
                            }
                        }
                    }
                }
                else
                {
                    string dateStr = DateTime.Now.ToString("yyyyMMdd");
                    var unit = Create(0, dateStr, bOutline);
                    if (unit != null)
                    {
                        unit.Row = 0;
                        unit.Column = 0;
                        tblCalendars.Controls.Add(unit, 0, 0);

                        if (wi < unit.Width)
                            wi = unit.Width;
                        if (hi < unit.Height)
                            hi = unit.Height;

                        ++countCalendars;
                        SelectionDates.Add(new CjSelectionDates(0, dateStr.Substring(0, 6)));
                    }
                }

                m_nUnitWidth = wi + SystemInformation.FrameBorderSize.Width * 2;
                m_nUnitHeight = hi + SystemInformation.FrameBorderSize.Height * 2;
                wi = m_nColCount * m_nUnitWidth + SystemInformation.FrameBorderSize.Width * 2;
                hi = m_nRowCount * m_nUnitHeight + SystemInformation.FrameBorderSize.Height * 2;

                this.Size = new Size(wi, hi);
                //tblCalendars.Size = new Size(wi, hi);
                this.tblCalendars.RowCount = m_nRowCount;
                this.tblCalendars.ColumnCount = m_nColCount;

                SetUnitSize(m_nUnitWidth, m_nUnitHeight);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            return countCalendars;
        }

        /// <summary>
        /// 달력 생성하기
        /// </summary>
        /// <param name="year">년 (1~9999)</param>
        /// <param name="month">월 (1~12)</param>
        /// <param name="bOutline">외곽라인이 있는지 여부 (default=false)</param>
        /// <returns>성공여부</returns>
        public CjCalendarUnit Create(int idx, int year, int month, bool bOutline = false)
        {
            try
            {
                return Create(idx, string.Format("{0:D4}{1:D2}", year, month), bOutline); ;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            return null;
        }

        /// <summary>
        /// 달력 생성하기
        /// </summary>
        /// <param name="idx">달력 순번(zero-based)</param>
        /// <param name="dateStr">생성할 달력의 년월(yyyyMM 또는 yyyyMMdd)</param>
        /// <param name="bOutline">외관경계선의 존재 여부</param>
        /// <returns>성공여부</returns>
        public CjCalendarUnit Create(int idx, string dateStr, bool bOutline = false)
        {
            try
            {
                DateTime dt;
                if ((dateStr.Length >= 8 && !DateTime.TryParseExact(dateStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt))
                    || !DateTime.TryParseExact(dateStr.Substring(0, 6) + "01", "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out dt))
                {
                    Debug.WriteLine($"달력생성 오류: 잘못된 날짜 매개변수 ({dateStr})");
                    return null;
                }

                CjCalendarUnit unit = new CjCalendarUnit(idx, dt.ToString("yyyyMMdd"), bOutline);
                if (unit.Successed)
                {
                    return unit;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            return null;
        }

        /// <summary>
        /// 단위달력의 크기 구하기
        /// </summary>
        /// <returns>Size</returns>
        public Size GetUnitSize()
        {
            return new Size(UnitWidth, UnitHeight);
        }

        /// <summary>
        /// 단위달력의 크기 설정하기
        /// </summary>
        /// <param name="wi">단위달력의 폭</param>
        /// <param name="hi">단위달력의 높이</param>
        public void SetUnitSize(int wi = MinWidth, int hi = MinHight)
        {
            try
            {
                m_nUnitWidth = wi + SystemInformation.FrameBorderSize.Width;
                m_nUnitHeight = hi + SystemInformation.FrameBorderSize.Height;

                if (this.tblCalendars.RowStyles.Count > 0)
                {
                    for (int r = 0; r < this.tblCalendars.RowStyles.Count; ++r)
                    {
                        this.tblCalendars.RowStyles[r].SizeType = SizeType.Absolute;
                        this.tblCalendars.RowStyles[r].Height = m_nUnitHeight;
                    }
                }

                if (this.tblCalendars.ColumnStyles.Count > 0)
                {
                    for (int c = 0; c < this.tblCalendars.ColumnStyles.Count; ++c)
                    {
                        this.tblCalendars.ColumnStyles[c].SizeType = SizeType.Absolute;
                        this.tblCalendars.ColumnStyles[c].Width = m_nUnitWidth;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// 선택된 날짜(기간)을 저장한다. 단, 주어진 인덱스를 가진 기존 데이터는 삭제한다.
        /// </summary>
        /// <param name="idx">선택된 날짜그룹의 인덱스</param>
        /// <param name="startDate">선택시작일</param>
        /// <param name="endDate">선택종료일</param>
        public void SetSelectionDates(int idx, string startDate, string endDate)
        {
            try
            {
                DateTime st = DateTime.ParseExact(startDate, "yyyyMMdd", null);
                DateTime et = DateTime.ParseExact(endDate, "yyyyMMdd", null);

                /// 기존 인덱스를 가진 데이터를 삭제한다.
                var lst = (from CjSelectionDates v in SelectionDates
                           where v.Index == idx
                           select v).ToList();
                if (lst != null)
                {
                    while (lst.Count > 0)
                    {
                        lst.Remove(lst.Last());
                    }
                }

                SelectionDates.Add(new CjSelectionDates(idx, st, et));
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// 선택된 날짜(기간)을 저장한다. 단, 주어진 인덱스를 가진 기존 데이터는 삭제한다.
        /// </summary>
        /// <param name="idx">선택된 날짜그룹의 인덱스</param>
        /// <param name="days">선택된 날짜들 (yyyyMMdd)</param>
        public void SetSelectionDates(int idx, string[] days)
        {
            try
            {
                if (days == null || days.Count() < 1)
                {
                    return;
                }

                /// 기존 인덱스를 가진 데이터를 삭제한다.
                var lst = (from CjSelectionDates v in SelectionDates
                           where v.Index == idx
                           select v).ToList();
                if (lst != null)
                {
                    while (lst.Count > 0)
                    {
                        lst.Remove(lst.Last());
                    }
                }

                CjSelectionDates cjSelectionDates = new CjSelectionDates(idx, days.ToString());
                cjSelectionDates.Method = 1;
                SelectionDates.Add(cjSelectionDates);
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
        }
        #endregion

        #region 내부함수
        /// <summary>
        /// 날짜를 클릭했을 때
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnClickDays(object sender, EventArgs e)
        {
            try
            {
                Debug.WriteLine($"{sender.ToString()}");
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }
        #endregion

        #region CjSelectionDates
        /// <summary>
        /// 선택된 날짜 그룹
        /// </summary>
        public class CjSelectionDates
        {
            #region attributes
            /// <summary>
            /// 선택된 날짜 그룹의 순번 (zero-based)
            /// - -1이면 선택된 날짜가 없다.
            /// - -1이 아니면 선택된 날짜가 있다.
            /// </summary>
            public int Index { get; set; } = -1;

            /// <summary>
            /// 선택된 날짜의 유형 (default=0)
            /// </summary>
            /// <remarks>
            /// - 0 = 연결된 날짜로 구성된 그룹으로 시작날짜와 종료날짜가 있다.
            /// - 1 = 낱개로 구성된 날짜의 그룹으로 시작날짜와 종료날짜가 없다.
            /// </remarks>
            public int Method { get; set; } = 0;

            /// <summary>
            /// 선택한 날짜 그룹의 시작날짜
            /// </summary>
            public CjDay Start { get; set; } = null;
            /// <summary>
            /// 선택한 날짜 그룹의 종료날짜
            /// </summary>
            public CjDay End { get; set; } = null;

            /// <summary>
            /// 개별 날짜 모음
            /// </summary>
            public List<CjDay> Days { get; set; } = new List<CjDay>();
            #endregion

            #region 생성자
            /// <summary>
            /// 생성자
            /// </summary>
            public CjSelectionDates()
            {
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="year">선택된 년도</param>
            /// <param name="month">선택된 월</param>
            public CjSelectionDates(int idx, int year, int month)
            {
                DateTime today = new DateTime(year, month, 1);
                if (idx >= 0 && today != DateTime.MinValue && today != DateTime.MaxValue)
                {
                    Index = idx;
                    Method = 0;

                    this.Start = new CjDay(today);
                    this.End = new CjDay(today);
                }
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="dateStr">선택된 날짜 문자열(yyyyMMdd)</param>
            public CjSelectionDates(int idx, string dateStr)
            {
                try
                {
                    if (!DateTime.TryParseExact(dateStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AssumeLocal, out DateTime today))
                    {
                        Debug.WriteLine("CjSelectionDates error: 올바르지않은 날짜 형태입니다." + dateStr);
                        return;
                    }

                    Index = (idx < 0 ? -1 : idx);
                    Method = 0;

                    this.Start = new CjDay(today);
                    this.End = new CjDay(today);
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                }
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="today">선택된 날짜</param>
            public CjSelectionDates(int idx, DateTime today)
            {
                if (idx >= 0 && today != DateTime.MinValue && today != DateTime.MaxValue)
                {
                    Index = idx;
                    Method = 0;

                    this.Start = new CjDay(today);
                    this.End = new CjDay(today);
                }
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="start">선택된 시작날짜</param>
            /// <param name="end">선택된 종료날짜</param>
            public CjSelectionDates(int idx, DateTime start, DateTime end)
            {
                if (idx >= 0
                    && start != DateTime.MinValue && start != DateTime.MaxValue
                    && end != DateTime.MinValue && end != DateTime.MaxValue)
                {
                    Index = idx;
                    Method = 0;

                    this.Start = (start <= end) ? new CjDay(start) : new CjDay(end);
                    this.End = (start <= end) ? new CjDay(end) : new CjDay(start);
                }
                else
                    Debug.WriteLine($"잘못된 매개변수: 순번={idx}, 시작날짜={start}, 종료날짜={end}");
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="days">선택된 날짜들(yyyyMM)</param>
            public CjSelectionDates(int idx, List<string> days)
            {
                if (idx >= 0 && days != null && days.Count > 0)
                {
                    Index = idx;
                    Method = 1;

                    if (Days == null)
                        Days = new List<CjDay>();

                    var lst = from string v in days orderby v select v;
                    foreach (string v in lst)
                    {
                        Days.Add(new CjDay(v));
                    }
                }
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="days">선택된 날짜들</param>
            public CjSelectionDates(int idx, List<DateTime> days)
            {
                if (idx >= 0 && days != null && days.Count > 0)
                {
                    Index = idx;
                    Method = 1;

                    if (Days == null)
                        Days = new List<CjDay>();

                    var lst = from DateTime v in days orderby v select v;
                    foreach (DateTime v in lst)
                    {
                        Days.Add(new CjDay(v));
                    }
                }
            }

            /// <summary>
            /// 생성자
            /// </summary>
            /// <param name="idx">순번 (zero-based)</param>
            /// <param name="days">선택된 날짜들</param>
            public CjSelectionDates(int idx, List<CjDay> days)
            {
                if (idx >= 0 && days != null && days.Count > 0)
                {
                    Index = idx;
                    Method = 1;

                    if (Days == null)
                        Days = new List<CjDay>();

                    var lst = from DateTime v in days orderby v select v;
                    foreach (DateTime v in lst)
                    {
                        Days.Add(new CjDay(v));
                    }
                }
            }
            #endregion

            /// <summary>
            /// 선택된 달력 리스트
            /// </summary>
            public List<string> getMonthList()
            {
                List<string> rt = new List<string>();

                if (Method == 0)
                {
                    if (Start != null && End != null)
                    {
                        for (DateTime dt = Start.Date; dt <= End.Date; dt.AddMonths(1))
                            rt.Add(dt.ToString("yyyyMM"));
                    }
                    else if (Start != null)
                    {
                        rt.Add(Start.Date.ToString("yyyyMM"));
                    }
                }
                else
                {
                    if (Days.Count > 0)
                    {
                        var lst = (from CjDay v in Days orderby v.Date select new DateTime(v.Year, v.Month, 1)).Distinct().ToList();
                        foreach (DateTime v in lst)
                            rt.Add(v.ToString("yyyyMM"));
                    }
                }

                return rt;
            }
        }
        #endregion
    }
}

예제:

CjControls.7z

0.06MB

[clr] Window Forms 컨트롤 라이브러리 MFC에서 사용하기 사용

DevReff — Tue, 6 May 2025 12:39:35 +0900

1. CLR (Common Language Runtime)은?

- CLR은 마이크로소프트의 .NET 프레임워크에서 프로그램을 실행하는 환경입니다.
- CLR은 C#, VB.NET, F# 등 다양한 언어로 작성된 코드를 실행할 수 있도록 지원합니다.
- CLR은 코드의 실행, 메모리 관리 (가비지 컬렉션), 보안, 예외 처리 등의 기능을 제공합니다.

2. Window Forms 컨트롤 라이브러리 사용

1) C#에서 라이브러리 (.dll)을 생성한다.

2) MFC 프로젝트를 생성한다.

3) MFC 프로젝트의 속성 중에서 아래와 같이 <공용 언어 런타임 지원> 속성을 .NET Framework 런타임 지원(/clr)로 설정한다.

4) 윈도우를 생성한 후 컨트롤과 관련 된코드를 추가한다. (예: 다이얼로그)

- 헤더파일(.h)에 컨트롤 라이브러리에서 사용하려는 컨트롤을 아래와 같은 형식으로 변수로 선언한다.

CWinFormsControl<컨트롤_라이브러리의_nammespace:: 컨트롤_라이브러리의_컨트롤명> 변수명;

예: CWinFormsControl<MyControls::MyLabel> m_Name;

- 소스파일(.cpp)의 DoDataExchange(CDataExchange* pDX) 함수에서

선언한 변수와 컨트롤을 연결하기 위해서 아래와 같이 코드를 추가한다.

DDX_ManagedControl(pDX, 컨트롤ID, 변수명);

예: DDX_ManagedControl(pDX, IDC_MYLABEL, m_Name);

- 컨트롤에서 발생하는 이벤트를 처리하기 위해서는 아래처럼 코드를 추가한다.

헤더파일에 아래와 같은 코드를 추가하고

public:

BEGIN_DELEGATE_MAP( CMFCTestDialog )
//EVENT_DELEGATE_ENTRY( 이벤트명칭, 이벤트발생컨트롤^, 이벤트정보를담고있는매개변수^ )
EVENT_DELEGATE_ENTRY( OnClick, System::Object^, System::EventArgs^ )
END_DELEGATE_MAP()

//void 이벤트명 (이벤트발생컨트롤^ 변수명1, 이벤트정보를담고있는매개변수^ 변수명2);
예: void OnClick( System::Object^ sender, System::EventArgs^ e );

그리고 소스파일(.cpp)에서 컨트롤이 표시되기 전에 처리되는 함수 즉, 다이얼로그의 OnInitDialog() 함수 속에

아래와 같은 형식으로 코드를 추가한다.

//변수명.이벤트명 += MAKE_DELEGATE( System::EventHandler, OnClick );
예: m_ctrl1.GetControl()->button1->Click += MAKE_DELEGATE( System::EventHandler, OnClick );

BEGIN_DELEGATE_MAP 매크로는,
Windows Form 컨트롤에서 발생한 이벤트(Managed Event)에 대한 Call-Back 처리가 가능하도록 연결다.
그러므로 .NET 사용자 컨트롤에서 발생한 버튼 클릭 이벤트는 .NET 코드에서 먼저 처리되고,
연결된 C++ 다이얼로그 클래스에 구현된 OnClick 함수를 통하여 처리된다.

[C#] DataGridView 자동 행 번호 생성하는 방법(예제)

DevReff — Mon, 5 May 2025 11:44:56 +0900

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CjControls
{
    public partial class CjDataGridView : DataGridView
    {
        #region Attributes
        /// <summary>
        /// 행번호를 자동으로 생성할지 여부 (default=false). RowHeadersVisible=true일 때 사용 가능함
        /// </summary>
        private bool m_bAutoRowIndex = false;
        [Browsable(true)]
        [Category("CjDataGridView")]
        [Description("행번호를 자동으로 생성할지 여부. RowHeadersVisible=true일 때 사용 가능함")]
        [DefaultValue(false)]
        public bool IsAutoRowIndex
        {
            get { return m_bAutoRowIndex; }
            set
            {
                this.RowHeadersVisible = value;
                if (m_bAutoRowIndex != value)
                {
                    m_bAutoRowIndex = value;
                    this.Update();
                }
            }
        }

        /// <summary>
        /// 수평 스크롤바를 제거하도록 마지막 컬럼의 폭을 자동 조정할지의 여부 (default=true)
        /// </summary>
        private bool m_bAutoRemoveHScrollbar = true;
        [Browsable(true)]
        [Category("CjDataGridView")]
        [Description("수평 스크롤바를 제거하도록 마지막 컬럼의 폭을 자동 조정할지의 여부")]
        [DefaultValue(true)]
        public bool IsAutoRemoveHScrollbar
        {
            get { return m_bAutoRemoveHScrollbar; }
            set
            {
                m_bAutoRemoveHScrollbar = value;
            }
        }

        /// <summary>
        /// 자동으로 생성되는 행의 시작번호 (default=1)
        /// </summary>
        private int m_nAutoIndexStartNo = 1;
        [Browsable(true)]
        [Category("CjDataGridView")]
        [Description("자동으로 생성되는 행의 시작번호")]
        [DefaultValue(1)]
        public int AutoIndexStartNo
        {
            get { return m_nAutoIndexStartNo; }
            set
            {
                if (value < 0)
                    return;
                m_nAutoIndexStartNo = value;
            }
        }

        [Browsable(false)]
        [Category("CjDataGridView")]
        [Description("바인딩 데이터테이블")]
        [DefaultValue(null)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public System.Data.DataTable BindingToTable
        {
            get
            {
                if (this.Columns.Count > 0)
                {
                    System.Data.DataTable dt = new System.Data.DataTable();

                    var cols = from DataGridViewColumn v in this.Columns orderby v.Index select v;
                    foreach (DataGridViewColumn v in cols)
                    {
                        System.Data.DataColumn c = dt.Columns.Add(v.Name, v.ValueType);
                        c.Caption = v.HeaderText;
                    }

                    var rows = from DataGridViewRow v in this.Rows orderby v.Index select v;
                    foreach (DataGridViewRow v in rows)
                    {
                        object[] dr = new object[this.Columns.Count];
                        for (int c = 0; c < this.Columns.Count; ++c)
                        {
                            dr[c] = this.Rows[v.Index].Cells[c].Value;
                        }
                        dt.Rows.Add(dr);
                    }

                    return dt;
                }
                else
                    return null;
            }
        }

        [Browsable(false)]
        [Category("CjDataGridView")]
        [Description("바인딩 데이터셋")]
        [DefaultValue(null)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public System.Data.DataSet BindingToSet
        {
            get
            {
                if (this.Columns.Count > 0)
                {
                    System.Data.DataSet ds = new System.Data.DataSet();
                    System.Data.DataTable dt = new System.Data.DataTable();

                    var cols = from DataGridViewColumn v in this.Columns orderby v.Index select v;
                    if (cols.Count() > 0)
                    {
                        foreach (DataGridViewColumn v in cols)
                        {
                            dt.Columns.Add(v.Name, v.ValueType);
                        }
                    }

                    var rows = from DataGridViewRow v in this.Rows orderby v.Index select v;
                    if (rows.Count() > 0)
                    {
                        foreach (DataGridViewRow v in rows)
                        {
                            object[] dr = new object[this.Columns.Count];
                            for (int c = 0; c < this.Columns.Count; ++c)
                                dr[c] = this.Rows[v.Index].Cells[c].Value;
                            dt.Rows.Add(dr);
                        }
                    }

                    ds.Tables.Add(dt);

                    return ds;
                }
                else
                    return null;
            }
        }

        [Browsable(false)]
        [Category("CjDataGridView")]
        [Description("바인딩 리스트")]
        [DefaultValue(null)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public BindingList<object> BindingToList
        {
            get
            {
                if (this.Columns.Count > 0 && this.Rows.Count > 0)
                {
                    BindingList<object> list = new BindingList<object>();
                    object[,] objects = new object[this.Rows.Count, this.Columns.Count];

                    var cols = (from DataGridViewColumn v in this.Columns orderby v.Index select v).ToList();
                    if (cols.Count() > 0)
                    {
                        for (int c = 0; c < this.Columns.Count; ++c)
                        {
                            objects[0, c] = cols[c].Name;
                        }
                    }

                    var rows = (from DataGridViewRow v in this.Rows orderby v.Index select v).ToList();
                    if (rows.Count() > 0)
                    {
                        for (int r = 0; r < this.Rows.Count; ++r)
                        {
                            for (int c = 0; c < this.Columns.Count; ++c)
                                objects[r, c] = rows[r].Cells[c].Value;
                        }
                    }

                    list.Add(objects);

                    return list;
                }
                else
                    return null;
            }
        }

        /// <summary>
        /// 칼럼별 수평 출력 방식
        /// </summary>
        private DataGridViewContentAlignment[] m_lstColumnAligns = null;
        [Browsable(true)]
        [Category("CjDataGridView")]
        [Description("칼럼별 수평 출력 방식")]
        [DefaultValue(null)]
        public DataGridViewContentAlignment[] ColumnAligns
        {
            get { return m_lstColumnAligns; }
            set
            {
                if (this.m_lstColumnAligns != null)
                {
                    m_lstColumnAligns.Initialize();
                    m_lstColumnAligns = null;
                }
                m_lstColumnAligns = value;
                Refresh();
            }
        }
        #endregion

        #region 생성자
        /// <summary>
        /// 생성자
        /// </summary>
        public CjDataGridView()
            : base()
        {
            InitializeComponent();
        }

#if _REMOVE_GGAMBBAK
        /// <summary>
        /// 화면에 표시될 때 생기는 화면 깜빡임 방지
        /// </summary>
        protected override CreateParams CreateParams
        {
            get
            {
                var cp = base.CreateParams;
                cp.ExStyle |= 0x02000000;
                return cp;
            }
        }
#endif
        #endregion

        #region 컨트롤 이벤트 처리
        /// <summary>
        /// 마우스 다운했을 때
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseDown(MouseEventArgs e)
        {
            //Debug.WriteLine($"OnMouseDown started: {e.Button}, {e.Location}");
            base.OnMouseDown(e);
        }

        /// <summary>
        /// 사용자가 행을 추가한 후
        /// </summary>
        /// <param name="e"></param>
        protected override void OnUserAddedRow(DataGridViewRowEventArgs e)
        {
            try
            {
                base.OnUserAddedRow(e);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// 모든 셀 그리기가 발생한 후 행 수준 그리기를 수행하기 위해 발생하는 이벤트
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRowPostPaint(DataGridViewRowPostPaintEventArgs e)
        {
            try
            {
                if (IsAutoRowIndex)
                    DGV_AutoRowIndex(this, e);
                else
                    base.OnRowPostPaint(e);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            finally
            {
                if (IsAutoRemoveHScrollbar)
                    AutoRemoveHScrollbar();
            }
        }
        #endregion

        #region 외부함수
        /// <summary>
        /// 컨트롤 초기화
        /// </summary>
        /// <param name="bindingData">로딩할 데이터 데이블</param>
        public void InitControl(DataTable bindingData = null, List<DataGridViewContentAlignment> lstColumnAligns = null)
        {
            Cursor.Current = Cursors.WaitCursor;

            try
            {
                this.AllowUserToAddRows = false;
                this.AllowUserToDeleteRows = false;
                this.AllowUserToOrderColumns = false;
                this.AllowUserToResizeColumns = true;
                this.AllowUserToResizeRows = false;
                this.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
                this.ReadOnly = true;
                this.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
                this.RowHeadersVisible = IsAutoRowIndex;

                this.Columns.Clear();
                this.DataSource = null;

                if (lstColumnAligns != null)
                {
                    if (this.m_lstColumnAligns != null)
                    {
                        m_lstColumnAligns.Initialize();
                        m_lstColumnAligns = null;
                    }
                    this.m_lstColumnAligns = lstColumnAligns.ToArray();
                }

                if (bindingData != null && bindingData.Columns.Count > 0)
                {
                    int wi = (this.Width - (IsAutoRowIndex ? this.RowHeadersWidth : 0)) / bindingData.Columns.Count;

                    for (int i = 0; i < bindingData.Columns.Count; i++)
                    {
                        DataColumn col = bindingData.Columns[i];
                        int c = this.Columns.Add(col.ColumnName, col.Caption);
                        this.Columns[c].DataPropertyName = col.ColumnName;
                        this.Columns[c].Width = wi;

                        if (m_lstColumnAligns == null)
                            m_lstColumnAligns = new DataGridViewContentAlignment[bindingData.Columns.Count];
                        if (m_lstColumnAligns.Count() <= c)
                            m_lstColumnAligns.Append(this.Columns[c].DefaultCellStyle.Alignment);
                        else
                            this.Columns[c].DefaultCellStyle.Alignment = m_lstColumnAligns[c];
                    }

                    foreach (DataRow row in bindingData.Rows)
                    {
                        int r = this.Rows.Add();
                        for (int c = 0; c < bindingData.Columns.Count; c++)
                        {
                            this.Rows[r].Cells[c].Value = row[c] as string;
                        }
                    }

                    this.DataSource = bindingData;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }

        /// <summary>
        /// 수평 스크롤바를 제거하도록 마지막 컬럼의 폭을 자동 조정한다.
        /// </summary>
        public void AutoRemoveHScrollbar()
        {
            try
            {
                int lastColumnWidth = (this.Width - (IsAutoRowIndex ? this.RowHeadersWidth : 0))
                    - (from DataGridViewColumn v in this.Columns
                       where v.Index != (this.Columns.Count - 1)
                       select v.Width).Sum();
                if (this.Width < this.RowTemplate.Height * this.Rows.Count)
                {
                    this.Columns[this.Columns.Count - 1].Width = lastColumnWidth
                        - SystemInformation.VerticalScrollBarWidth
                        - SystemInformation.FrameBorderSize.Width;
                    this.Update();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// DataGridView 의 RowHeader 에 일련번호 자동생성　
        /// </summary>
        /// <param name="sender">DataGridView 컨트롤</param>
        /// <param name="e">이벤트정보</param>
        /// <param name="startno">시작번호</param>
        /// <remarks>DataGridView의 RowPostPaint 이벤트에 사용함</remarks>
        public void DGV_AutoRowIndex(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            if (sender is DataGridView)
            {
                try
                {
                    DataGridView dgv = sender as DataGridView;
                    if (dgv != null && dgv.RowHeadersVisible && dgv.Rows.Count > 0 && e.RowIndex >= 0)
                    {
                        String rowIdx = (AutoIndexStartNo + e.RowIndex).ToString();
                        StringFormat centerFormat = new StringFormat()
                        {
                            Alignment = StringAlignment.Center,
                            LineAlignment = StringAlignment.Center
                        };

                        RectangleF headerBounds = new RectangleF(e.RowBounds.Left, e.RowBounds.Top, dgv.RowHeadersWidth, e.RowBounds.Height);
                        e.Graphics.DrawString(rowIdx, dgv.Font, SystemBrushes.ControlText, headerBounds, centerFormat);
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                }
            }
        }

        /// <summary>
        /// 칼럼별 출력 방식 설정하기
        /// </summary>
        /// <param name="formats">칼럼별 출력 방식</param>
        public void SetColumnAligns(List<DataGridViewContentAlignment> formats)
        {
            if (formats != null && formats.Count > 0)
            {
                if (m_lstColumnAligns != null)
                {
                    m_lstColumnAligns.Initialize();
                    m_lstColumnAligns = null ;
                }
                m_lstColumnAligns = formats.ToArray();
            }
        }

        /// <summary>
        /// 바인딩 리스트를 출력하기
        /// </summary>
        /// <param name="sb">저장할 문자열 목록</param>
        /// <param name="limit">한계 행 갯수 (0이면 무시, 0보다 클때만 적용됨)</param>
        /// <param name="bDebug">디버깅창에 출력만 할 것인지 여부</param>
        public void OutputBindingToList(out StringBuilder sb, int limit = 0, bool bDebug = true)
        {
            sb = new StringBuilder();

            if (BindingToList != null)
            {
                foreach (object[,] v in BindingToList)
                {
                    int nRow = v.GetLength(0);
                    int nCol = v.GetLength(1);

                    for (int r = 0; r < nRow; r++)
                    {
                        if (limit > 0 && r >= limit)
                            break;

                        string s = $"[{r + 1}] ";
                        for (int c = 0; c < nCol; c++)
                            s += $"{v[r, c].ToString()}, ";

                        if (!bDebug)
                            sb.AppendLine(s);
                        Debug.WriteLine(s);
                    }
                }
            }
        }

        #endregion
    }
}