Get it on Google Play


Wm뮤 :: '윈도우폼' 카테고리의 글 목록

블로그 이미지
가끔 그림그리거나 3D모델링하거나
취미로 로봇만드는
퇴직한 전자과 게임프로그래머
2020.3.48f1 , 2022.3.6f1 주로 사용
모카쨩
@Ahzkwid

Recent Comment

Archive


'윈도우폼'에 해당되는 글 13건

  1. 2024.01.15 윈폼 차트
  2. 2023.09.26 윈도우용 대화형 프로그램 설정
  3. 2023.07.25 윈폼 오류 모음
  4. 2022.02.16 C# 환경변수 설정
  5. 2021.07.19 잘 안 쓰는 윈폼코드 모음
  6. 2021.02.11 DLL 생성 예제
  7. 2021.01.17 윈폼 키보드마우스
  8. 2020.11.23 c# 멀티스레드 기본소스
2024. 1. 15. 22:58 윈도우폼

 

 

 

 

 

 

system.windows.forms.datavisualization

을 쳐서 설치

 

 

 

 

 

그리고 왠지 Form1이 이런 에러 뜨면서 닫혔다

 

 

 

업데이트 하면 고쳐진다

 

 

 

 

 

 

 

 

 

 

 

 

설치 끝

 

 

아래는 내가 자주 쓰는 차트 코드들이다

 

 

 

마우스 댄 곳의 차트값 표시

검색해도 제대로 만든 사람이 없고 챗GPT도 개소리만 해서 만드는데 고생함

 

V1

V1은 특정 차트만 사용한다

더보기
private void chart1_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart1, e);
}
private void chart2_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart2, e);
}
private void chart3_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart3,e);
}

DataPoint prePoint = null;
ToolTip tooltip = new ToolTip();
private void DrawChartValue(Chart chart, MouseEventArgs e)
{
    HitTestResult result = chart.HitTest(e.X, e.Y);
    if (result.PointIndex < 0)
    {
        return;
    }
    if (chart.Series.Count==0)
    {
        return;
    }
    if (result.PointIndex >= chart.Series[0].Points.Count)
    {
        return;
    }
    {
        var dataPoint = chart.Series[0].Points[result.PointIndex];
        var date = DateTime.FromOADate(dataPoint.XValue);
        var value = dataPoint.YValues[0];

        var text = $"Date: {date.ToShortDateString()}\nValue: {value.ToString("F2")}";
        if (tooltip.GetToolTip(chart) != text)
        {
            tooltip.AutoPopDelay = 60*1000; //60초
            tooltip.SetToolTip(chart, text);
        }
        if (prePoint != dataPoint)
        {
            if (prePoint != null)
            {
                prePoint.MarkerStyle = MarkerStyle.None;
            }
            prePoint = dataPoint;
            dataPoint.MarkerStyle = MarkerStyle.Circle;
            dataPoint.MarkerSize = 8;
            dataPoint.MarkerColor = System.Drawing.Color.Red;
        }
    }
}

 

V2 모든 차트 사용

더보기
private void chart1_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart1, e);
}
private void chart2_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart2, e);
}
private void chart3_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart3,e);
}

DataPoint prePoint = null;
ToolTip tooltip = new ToolTip();
private void DrawChartValue(Chart chart, MouseEventArgs e)
{
    if (chart.Series.Count == 0)
    {
        return;
    }
    var result = chart.HitTest(e.X, e.Y);
    //var result = HitTestX(chart,e);
    if (result.PointIndex < 0)
    {
        return;
    }
    if (result.Series==null)
    {
        return;
    }
    if (result.PointIndex >= result.Series.Points.Count)
    {
        return;
    }
    {
        var dataPoint = result.Series.Points[result.PointIndex];
        var date = DateTime.FromOADate(dataPoint.XValue);
        var value = dataPoint.YValues[0];

        var text = $"{result.Series.Name}\nDate: {date.ToShortDateString()}\nValue: {value.ToString("F2")}";
        if (tooltip.GetToolTip(chart) != text)
        {
            tooltip.AutoPopDelay = 60*1000; //60초
            tooltip.SetToolTip(chart, text);
        }
        if (prePoint != dataPoint)
        {
            if (prePoint != null)
            {
                prePoint.MarkerStyle = MarkerStyle.None;
            }
            prePoint = dataPoint;
            dataPoint.MarkerStyle = MarkerStyle.Circle;
            dataPoint.MarkerSize = 8;
            dataPoint.MarkerColor = System.Drawing.Color.Red;
        }
    }
}

 

 

 

V3

가로축만 사용하는 검색기를 만들었다

근데 만들고보니까 V1보단 낫지만 V2가 더 유용한듯

더보기
private void chart1_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart1, e);
}
private void chart2_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart2, e);
}
private void chart3_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(chart3,e);
}

DataPoint prePoint = null;
ToolTip tooltip = new ToolTip();
private void DrawChartValue(Chart chart, MouseEventArgs e)
{
    if (chart.Series.Count == 0)
    {
        return;
    }
    //var result = chart.HitTest(e.X, e.Y);
    var result = HitTestX(chart,e);
    if (result.PointIndex < 0)
    {
        return;
    }
    if (result.Series==null)
    {
        return;
    }
    if (result.PointIndex >= result.Series.Points.Count)
    {
        return;
    }
    {
        var dataPoint = result.Series.Points[result.PointIndex];
        var date = DateTime.FromOADate(dataPoint.XValue);
        var value = dataPoint.YValues[0];

        var text = $"{result.Series.Name}\nDate: {date.ToShortDateString()}\nValue: {value.ToString("F2")}";
        if (tooltip.GetToolTip(chart) != text)
        {
            tooltip.AutoPopDelay = 60*1000; //60초
            tooltip.SetToolTip(chart, text);
        }
        if (prePoint != dataPoint)
        {
            if (prePoint != null)
            {
                prePoint.MarkerStyle = MarkerStyle.None;
            }
            prePoint = dataPoint;
            dataPoint.MarkerStyle = MarkerStyle.Circle;
            dataPoint.MarkerSize = 8;
            dataPoint.MarkerColor = System.Drawing.Color.Red;
        }
    }
}
public static HitTestResult HitTestX(Chart chart, MouseEventArgs e)
{
    var hitTestResult = new HitTestResult();

    var chartArea = chart.ChartAreas[0];
    chartArea.CursorX.SetCursorPixelPosition(new Point(e.X, e.Y), true);
    var result = chart.HitTest(e.X, e.Y);
    if (result.ChartArea == null)
    {
        return hitTestResult;
    }
    var xValue = chartArea.AxisX.PixelPositionToValue(e.X);

    foreach (var series in chart.Series)
    {
        for (int i = 1; i < series.Points.Count; i++)
        {
            if ((series.Points[i-1].XValue + series.Points[i].XValue) / 2 < xValue)
            {
                continue;
            }
            hitTestResult.Series = series;
            hitTestResult.PointIndex = i-1;
            return hitTestResult;
        }
    }

    return hitTestResult;
}

 

 

 

V4

V2를 더욱 개량하여  단일 함수, 단일인자로 통합시킴

prams가 들어가서 필요하다면 V2에 쓰이던 시스템과 호환도 가능하다

public Form1()
{
    InitializeComponent();

    foreach (var chart in Charts)
    {
        chart.MouseMove += charts_MouseMove;
    }
}

private void charts_MouseMove(object sender, MouseEventArgs e)
{
    DrawChartValue(Charts);
}
Chart[] Charts
{
    get
    {
        return new Chart[] { chart1, chart2, chart3 };
    }
}
DataPoint prePoint = null;
ToolTip tooltip = new ToolTip();
private void DrawChartValue(params Chart[] charts)
{

    Chart chartMain = null;
    var mousePosition = Point.Empty;
    foreach (var chart in charts)
    {
        mousePosition = chart.PointToClient(MousePosition);
        if (chart.ClientRectangle.Contains(mousePosition))
        {
            //차트 내부인지 검사절차를 거치지 않으면 다른 이벤트와 충돌 가능성이 있다
            chartMain = chart;
            break;
        }
    }
    if (chartMain == null)
    {
        return;
    }

    {
        var chart = chartMain;



        if (chart.Series.Count == 0)
        {
            return;
        }


        var result = chart.HitTest(mousePosition.X, mousePosition.Y);
        //var result = HitTestX(chart,e);
        if (result.PointIndex < 0)
        {
            return;
        }
        if (result.Series == null)
        {
            return;
        }
        if (result.PointIndex >= result.Series.Points.Count)
        {
            return;
        }
        {
            var dataPoint = result.Series.Points[result.PointIndex];
            var date = DateTime.FromOADate(dataPoint.XValue);
            var value = dataPoint.YValues[0];

            var text = $"{result.Series.Name}\nDate: {date.ToShortDateString()}\nValue: {value.ToString("F2")}";
            if (tooltip.GetToolTip(chart) != text)
            {
                tooltip.AutoPopDelay = 60 * 1000; //60초
                tooltip.SetToolTip(chart, text);
            }
            if (prePoint != dataPoint)
            {
                if (prePoint != null)
                {
                    prePoint.MarkerStyle = MarkerStyle.None;
                }
                prePoint = dataPoint;
                dataPoint.MarkerStyle = MarkerStyle.Circle;
                dataPoint.MarkerSize = 8;
                dataPoint.MarkerColor = System.Drawing.Color.Red;
            }
        }
    }
}

 

 

 

 

 

차트 XY커서 표시

GPT도 답변을 제대로 안 해주고 검색해도 안 나와서 머리 부딪히면서 만듦

public Form1()
{
    InitializeComponent();

    chart1.MouseMove += charts_MouseMove;
}
private void charts_MouseMove(object sender, MouseEventArgs e)
{
    DrawCursors(Charts);
}
Chart[] Charts
{
    get
    {
        return new Chart[] { chart1, chart2, chart3 };
    }
}
void DrawCursors(params Chart[] charts)
{
    Chart chartMain = null;
    var mousePosition = Point.Empty;
    foreach (var chart in charts)
    {
        mousePosition = chart.PointToClient(MousePosition);
        if (chart.ClientRectangle.Contains(mousePosition))
        {
            //차트 내부인지 검사절차를 거치지 않으면 다른 이벤트와 충돌 가능성이 있다
            chartMain = chart;
            break;
        }
    }
    if (chartMain == null)
    {
        return;
    }

    {
        var chart = chartMain;
        var result = chart.HitTest(mousePosition.X, mousePosition.Y);
        if (result.ChartArea == null)
        {
            return;
        }
    }


    //X커서 표시(실수)
    {
        var chart = chartMain;
        var x = mousePosition.X;
        x = Math.Min(x, chart.Width - 20);
        x = Math.Max(0, x);
        double xValue = chart.ChartAreas[0].AxisX.PixelPositionToValue(x);
        chart.ChartAreas[0].CursorX.Position = xValue;
    }



    //Y커서 표시(실수)
    {
        var chart = chartMain;
        var y = mousePosition.Y;
        y = Math.Min(y, chart.Height - 20);
        y = Math.Max(0, y);
        double yValue = chart.ChartAreas[0].AxisY.PixelPositionToValue(y);
        chart.ChartAreas[0].CursorY.Position = yValue;

    }


    var xPosition = chartMain.ChartAreas[0].CursorX.Position;
    //X커서 복제
    foreach (var chart in Charts)
    {
        chart.ChartAreas[0].CursorX.Position = xPosition;
    }
}

 

 

 

'윈도우폼' 카테고리의 다른 글

윈도우용 대화형 프로그램 설정  (0) 2023.09.26
윈폼 오류 모음  (0) 2023.07.25
C# 환경변수 설정  (0) 2022.02.16
posted by 모카쨩
2023. 9. 26. 13:42 윈도우폼

네이버카페에 썼던 16년글 이전

 

Properties에서

FormBorderStyle을 None로 설정
BackgroundImageLayout를 Center로 설정
Size를 0,0으로 설정 //윈도우에서는 최소 윈도우 크기가 한정되어 있다
Location을 -100,-100으로 설정
StartPosition을 Manual로 설정

ShowIcon을 False로 설정

ShowInTaskbar를 False로 설정
 
 
 
다음과 같이 변수를 초기화 한다
 
        입력창 입력창변수;
 
생성자에 다음과 같이 써 넣는다

            this.TransparencyKey = BackColor;

            //SetStyle(ControlStyles.SupportsTransparentBackColor, true);
 
            //컨트롤명.BackColor = Color.Transparent;
 
            //this.TransparencyKey = System.Drawing.Color.FromArgb(0x78F0F0F0);
//투명컨트롤이 필요할경우(호환 비보장)
 
//CheckForIllegalCrossThreadCalls = false; 크로스 스레드 사용시
 
            this.BackgroundImage = new Bitmap("사진 파일 위치, 240*240이상 권장");
 
            this.Width = BackgroundImage.Width;
            this.Height = BackgroundImage.Height;
 
            this.Location = new Point(Screen.PrimaryScreen.Bounds.Width - this.Width, Screen.PrimaryScreen.Bounds.Height - this.Height);
//맨 윗줄에 넣을것
 
            this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.mouse_down);
 
 
 
 
 
 
 
 
//다음과 같은 이벤트를 추가한다
        private void mouse_down(object sender, MouseEventArgs e)
        {
            if ((입력창변수== null) || ((입력창변수.IsDisposed)))
            {
                입력창변수= new 입력창();
            }
            if (입력창변수 != null)
            {
                입력창변수.Show();
                입력창변수.Enabled = true;
            }
        }
 
 
 
 
 
다른창에서 AI를 호출할경우
if(this.Enabled == false)
{
this.Opacity=0.5;
this.TopMost=true;
}

'윈도우폼' 카테고리의 다른 글

윈폼 차트  (0) 2024.01.15
윈폼 오류 모음  (0) 2023.07.25
C# 환경변수 설정  (0) 2022.02.16
posted by 모카쨩
2023. 7. 25. 09:18 윈도우폼

 

 

 

 

------------------------------------------------------------------------------------------------------------------------------

모든 차트 영역 요소의 위치를 계산하기 전에는 PositionToValue 메서드를 호출할 수 없습니다

PositionToValue method cannot be called prior to calculating position of all chart area elements.

 

 

MouseMove 이벤트중에 PixelPositionToValue를 호출해서 발생했는데

아래와 같이 HitTest를 먼저 진행해서 하면 해결된다

var result = chart.HitTest(e.X, e.Y);
if (result.ChartArea != null)
{
    var xValue = chartArea.AxisX.PixelPositionToValue(e.X);
}

 

 

 

------------------------------------------------------------------------------------------------------------------------------

System.ArgumentException: '이름이 '차트이름'인 차트 요소를 'SeriesCollection'에서 찾을 수 없습니다.'

chart.ChartAreas[0].CursorX.SetCursorPixelPosition(mousePosition, true);

할때 발생했는데 이거도 역시 이벤트 충돌로 인해 발생한 결과로 다음과 같이 수정했다


//X커서 표시(실수)
{
    var x = mousePosition.X;
    x = Math.Max(0, x);
    x = Math.Min(x, chart.Width);
    double xValue = chart.ChartAreas[0].AxisX.PixelPositionToValue(x);
    chart.ChartAreas[0].CursorX.Position = xValue;
    position = chart.ChartAreas[0].CursorX.Position;
}

 

 

 

 

 

 

 

 

 

 

 

 

'윈도우폼' 카테고리의 다른 글

윈도우용 대화형 프로그램 설정  (0) 2023.09.26
C# 환경변수 설정  (0) 2022.02.16
잘 안 쓰는 윈폼코드 모음  (0) 2021.07.19
posted by 모카쨩
2022. 2. 16. 15:12

보호되어 있는 글입니다.
내용을 보시려면 비밀번호를 입력하세요.

2021. 7. 19. 11:36 윈도우폼

 

 

 

 

비프

System.Console.Beep();

 

 

 

차트에 가로선 긋기

근데 너무 후져서 안 씀

var stripLine = new StripLine();
stripLine.Interval = 0; //0으로 설정하여 축 전체에 걸쳐 가로선을 그립니다
stripLine.IntervalOffset = value; // 가로선의 y값
stripLine.StripWidth = (chart.ChartAreas[0].AxisY.Maximum - chart.ChartAreas[0].AxisY.Minimum )/ chart1.ClientSize.Height * 8; // 가로선의 두께


stripLine.BackColor = color; // 가로선의 색상
stripLine.IntervalOffsetType = DateTimeIntervalType.Number;
chart.ChartAreas[0].AxisY.StripLines.Add(stripLine);

 

 

 

차트 그래디언트 배경


{
    //그래디언트 배경
    chart1.ChartAreas[0].AxisY.StripLines.Clear();

    var count = 4;
    var colorDepth =10;
    for (int i = 0; i < count; i++)
    {
        var stripLine = new StripLine();
        stripLine.Interval = 0; // 가로선 간격 (0으로 설정하여 축 전체에 걸쳐 가로선을 그립니다)
        stripLine.StripWidth = 0.5 / count;
        stripLine.IntervalOffset = 0.5 + stripLine.StripWidth * i; // 가로선의 y값
        var gradiantColor = 255 - colorDepth + (colorDepth / count) * i;
        stripLine.BackColor = Color.FromArgb(gradiantColor, 255, gradiantColor); // 가로선의 색상
        stripLine.IntervalOffsetType = DateTimeIntervalType.Number; // y축 값의 타입 (Number로 설정)
        chart1.ChartAreas[0].AxisY.StripLines.Add(stripLine);
    }
    for (int i = 0; i < count; i++)
    {
        var stripLine = new StripLine();
        stripLine.Interval = 0; // 가로선 간격 (0으로 설정하여 축 전체에 걸쳐 가로선을 그립니다)
        stripLine.StripWidth = 0.5 / count;
        stripLine.IntervalOffset = 1 + stripLine.StripWidth * i; // 가로선의 y값
        var gradiantColor = 255 - colorDepth + (colorDepth / count) * (count-1-i);
        stripLine.BackColor = Color.FromArgb(255, gradiantColor, gradiantColor); // 가로선의 색상
        stripLine.IntervalOffsetType = DateTimeIntervalType.Number; // y축 값의 타입 (Number로 설정)
        chart1.ChartAreas[0].AxisY.StripLines.Add(stripLine);
    }
    {
        var stripLine = new StripLine();
        stripLine.Interval = 0; // 가로선 간격 (0으로 설정하여 축 전체에 걸쳐 가로선을 그립니다)
        stripLine.StripWidth = 0.01; 
        stripLine.IntervalOffset = 1.5; // 가로선의 y값
        stripLine.BackColor = Color.Red; // 가로선의 색상
        stripLine.IntervalOffsetType = DateTimeIntervalType.Number; // y축 값의 타입 (Number로 설정)
        chart1.ChartAreas[0].AxisY.StripLines.Add(stripLine);
    }
    {
        var stripLine = new StripLine();
        stripLine.Interval = 0; // 가로선 간격 (0으로 설정하여 축 전체에 걸쳐 가로선을 그립니다)
        stripLine.StripWidth = 0.01; 
        stripLine.IntervalOffset = 0.5 - stripLine.StripWidth; // 가로선의 y값
        stripLine.BackColor = Color.Green; // 가로선의 색상
        stripLine.IntervalOffsetType = DateTimeIntervalType.Number; // y축 값의 타입 (Number로 설정)
        chart1.ChartAreas[0].AxisY.StripLines.Add(stripLine);
    }
}

'윈도우폼' 카테고리의 다른 글

C# 환경변수 설정  (0) 2022.02.16
DLL 생성 예제  (0) 2021.02.11
윈폼 키보드마우스  (0) 2021.01.17
posted by 모카쨩
2021. 2. 11. 20:16 윈도우폼

깔아라

 

 

 

 

초 심플하게 8을 리턴하는 함수이다. 뭔가 이것저것 빠져있는데 왜 뺐는지 기억이 안난다. 잘 작동한다

#include <windows.h>
#include "stdafx.h"

extern "C" __declspec(dllexport) int m_test8()//완성판
{
	return 8;
};

눌러라

 

 

dll은 프로젝트폴더의 Debug폴더에 있다. 디버그가 싫으면 릴리즈로 하면 릴리즈 폴더에 생긴다

dll만 쓸거면 dll만 뽑으면 됨

 

 

불러오기 위해 C#폴더에 넣을건데 C#은 경로가 조금 다르다 

프로젝트 폴더/프로젝트이름 폴더/bin/Debug 폴더에 넣는다

프로젝트 폴더가 두개있는게 이상하지만 얘내가 그렇게 만든거니까 그러려니 하자

 

 

불러올때

using System;
using System.Windows.Forms;

namespace Dll_Import_Test
{
    static class Program
    {
        /// <summary>
        /// 해당 응용 프로그램의 주 진입점입니다.
        /// </summary>
        [System.Runtime.InteropServices.DllImport("user32.dll")] //키보드 상태
        public static extern int GetKeyboardState(byte[] pbKeyState);


        [System.Runtime.InteropServices.DllImport("Dll_Export_Test.dll")]
        public static extern int m_test8();


        [System.Runtime.InteropServices.DllImport("Dll_Export_Test.dll")]
        public static extern void m_test38(int[] _array);
        
        [STAThread]
        static void Main()
        {
            
            if (m_test8() == 8)
            {
                MessageBox.Show("m_test8() == 8");
            }
            else
            {
                MessageBox.Show("m_test8() 읽기 에러");
            }

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

        }
    }
}

동일 DLL에서 여러 함수를 불러오는 예제와 윈도우즈에 포함된 DLL을 불러오는 예제로 되어있다

 

 

 

 

 

38버전은 dll에서 배열로드버전이다

// Dll_Export_Test.cpp: 콘솔 응용 프로그램의 진입점을 정의합니다.
//
#include <windows.h>
#include "stdafx.h"

//extern은 내보낸다는 소리
//"C"은 C언어 규약으로 작성이랬던가 확실하지 않음, 이거 안넣으면 읽기실패
//__declspec(dllexport)은 dll로 내보내겠다는 뜻
//__stdcall 이건 호출방식인데 일반적으로 C#에선 __stdcall을씀(c++ 기본값은 __cdecl)
extern "C" __declspec(dllexport) void __stdcall m_test38(int _array[])//완성판
{
	for (int i = 0; i < 8; i++)
	{
		_array[i] = i;
	}
	return;
};

 

40버전은 길이를 입력받아서 처리하는거, 가능하면 자동화하고 싶었지만

C++의 배열시스템이 너무 후진적이라 이따구로 함

배열포인터에는 길이정보가 없다고 하니까 더 많은걸 바라지 말아라.

extern "C" __declspec(dllexport) void __stdcall m_test40(int _array[],int _length)
{
	for (int i = 0; i < _length; i++)
	{
		_array[i] = i;
	}
	return;
};

불러올떄

using System;
using System.Windows.Forms;

namespace Dll_Import_Test
{
    static class Program
    {
        /// <summary>
        /// 해당 응용 프로그램의 주 진입점입니다.
        /// </summary>
        [System.Runtime.InteropServices.DllImport("Dll_Export_Test.dll")]
        public static extern void m_test40(int[] _array,int _length);
        
        [STAThread]
        static void Main()
        {
            
            var _array = new int[16];
            m_test40(_array, _array.Length);
            MessageBox.Show($"m_test40(): [{string.Join(", ", _array)}]");
            
            

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

        }
    }
}

 

결과

 

 

 

여기까진 맛보기고 이제 다중 DLL 참조가 있다

'윈도우폼' 카테고리의 다른 글

잘 안 쓰는 윈폼코드 모음  (0) 2021.07.19
윈폼 키보드마우스  (0) 2021.01.17
c# 멀티스레드 기본소스  (0) 2020.11.23
posted by 모카쨩
2021. 1. 17. 04:56 윈도우폼
    public static class mMouse
    {
        [DllImport("User32.dll")]
        public static extern int SetCursorPos(int x, int y);
        [DllImport("User32.dll")]
        public static extern int GetCursorPos(ref Point pos);

        [DllImport("user32.dll")] // 마우스 입력 
        static extern void mouse_event(uint dwFlags, uint dx, uint dy, int dwData, int dwExtraInfo);

        [System.Runtime.InteropServices.DllImport("User32.dll")] //마우스 상태
        public static extern int GetKeyboardState(ref byte[] pbKeyState);

        [DllImport("User32.dll")]
        public static extern short GetKeyState(int nVirtualKey);

        [DllImport("user32.dll")]
        static extern void keybd_event(byte vk, byte scan, int flags, int extrainfo);

        /*
        
            const byte AltKey = 18;
            const int KEYUP = 0x0002;    
            int Info=0;
            keybd_event(AltKey, 0, 0, ref Info);   // ALT key 다운
            keybd_event(AltKey, 0, KEYUP, ref Info);  // ALT key 업
        */
        //[System.Runtime.InteropServices.DllImport("user32.dll")] //마우스 상태
        //[return: MarshalAs(UnmanagedType.Bool)]
        //public static extern bool GetKeyboardState(byte[] pbKeyState);

        #region mouse_flag
        private const uint
            Absolute = 0x8000,
            LeftDown = 0x0002,
            LeftUp = 0x0004,
            MiddleDown = 0x0020,
            MiddleUp = 0x0040,
            Move = 0x0001,
            RightDown = 0x0008,
            RightUp = 0x0010,
            Wheel = 0x0800,
            XDown = 0x0080,
            XUp = 0x0100,
            HWheel = 0x1000;
        #endregion

        #region mouse_state
        private const byte
            LeftButton = 1,
            MiddleButton = 4,
            RightButton = 2;
        #endregion

        private static byte[] key_state = new byte[256];
        //public static mVec2 pos;

        public static int x
        {
            get
            {
                Point _pos = new Point();
                GetCursorPos(ref _pos);
                return _pos.X;
            }
            set
            {
                SetCursorPos(value, y);
            }
        }
        public static int y
        {
            get
            {
                Point _pos = new Point();
                GetCursorPos(ref _pos);
                return _pos.Y;
            }
            set
            {
                SetCursorPos(x, value);
            }
        }
        public static Point pos
        {
            get
            {
                Point _pos = new Point();
                GetCursorPos(ref _pos);
                return new Point(_pos.X, _pos.Y);
            }
            set
            {
                SetCursorPos((int)value.X, (int)value.Y);
            }
        }

        public static bool left
        {
            get
            {
                return (GetKeyState(LeftButton) & 0x80) != 0;
            }
            set
            {
                //uint _flag_t;
                if (value)
                {
                    //keybd_event(0x01, 0, 0,0);   // ALT key 다운
                    mouse_event(LeftDown, 0, 0, 0, 0);
                }
                else
                {
                    //keybd_event(0x01, 0, 0x0002, 0);   // ALT key 다운
                    mouse_event(LeftUp, 0, 0, 0, 0);
                }
            }
        }
    }

 

 

 


    public static class mKey
    {
        [DllImport("User32.dll")]
        public static extern short GetKeyState(int nVirtualKey);

        [System.Runtime.InteropServices.DllImport("user32.dll")] //키보드 상태
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern int GetKeyboardState(byte[] pbKeyState);

        [DllImport("user32.dll")]
        static extern void keybd_event(byte vk, byte scan, int flags, int extrainfo);

        private static bool hangleToggle = false;

        #region keyState
        private const int
            key_down = 0x0000,
            key_up = 0x0002;
        #endregion

        #region kr_key_index_array
        private static string[]
            krSyllableFirst =
            {
                "ㄱ","ㄲ","ㄴ","ㄷ","ㄸ","ㄹ","ㅁ","ㅂ","ㅃ","ㅅ",
                "ㅆ","ㅇ","ㅈ","ㅉ","ㅊ","ㅋ","ㅌ","ㅍ","ㅎ"
            },
            krSyllableSecond =
            {
                "ㅏ","ㅐ","ㅑ","ㅒ","ㅓ","ㅔ","ㅕ","ㅖ","ㅗ","ㅗㅏ",
                "ㅗㅐ","ㅗㅣ","ㅛ","ㅜ","ㅜㅓ","ㅜㅔ","ㅜㅣ","ㅠ","ㅡ","ㅡㅣ",
                "ㅣ"
            },
            krSyllableThird =
            {
                "","ㄱ","ㄲ","ㄱㅅ","ㄴ","ㄴㅈ","ㄴㅎ","ㄷ","ㄹ","ㄹㄱ",
                "ㄹㅁ","ㄹㅂ","ㄹㅅ","ㄹㅌ","ㄹㅍ","ㄹㅎ","ㅁ","ㅂ","ㅂㅅ","ㅅ",
                "ㅆ","ㅇ","ㅈ","ㅊ","ㅋ","ㅌ","ㅍ","ㅎ"
            };
        #endregion


        #region VirtualKey
        public static byte


            vk_backspace = 0x08,
            vk_back = vk_backspace,  //BACKSPACE key

            vk_return = 0x0D,  //ENTER key
            vk_enter = vk_return,  //ENTER key

            vk_shift = 0x10,  //SHIFT key
            vk_control = 0x11,  //CTRL key
            vk_ctrl = vk_control,  //CTRL key


            vk_capital = 0x14,  //CAPS LOCK key
            vk_cap = vk_capital,  //CAPS LOCK key

            vk_hangul = 0x15, //hangul

            vk_escape = 0x1B,  //ESC key
            vk_esc = vk_escape,  //ESC key

            vk_space = 0x20,  //SPACEBAR


            vk_left = 0x25,  //LEFT ARROW key
            vk_le = vk_left,  //LEFT ARROW key
            vk_up = 0x26,  //UP ARROW key
            vk_right = 0x27,  //RIGHT ARROW key
            vk_ri = vk_right,  //RIGHT ARROW key
            vk_down = 0x28,  //DOWN ARROW key
            vk_do = vk_down,  //DOWN ARROW key




            vk_0 = 0x30,  //0 key
            vk_1 = 0x31,  //1 key
            vk_2 = 0x32,  //2 key
            vk_3 = 0x33,  //3 key
            vk_4 = 0x34,  //4 key
            vk_5 = 0x35,  //5 key
            vk_6 = 0x36,  //6 key
            vk_7 = 0x37,  //7 key
            vk_8 = 0x38,  //8 key
            vk_9 = 0x39,  //9 key
            vk_a = 0x41,  //A key
            vk_b = 0x42,  //B key
            vk_c = 0x43,  //C key
            vk_d = 0x44,  //D key
            vk_e = 0x45,  //E key
            vk_f = 0x46,  //F key
            vk_g = 0x47,  //G key
            vk_h = 0x48,  //H key
            vk_i = 0x49,  //I key
            vk_j = 0x4A,  //J key
            vk_k = 0x4B,  //K key
            vk_l = 0x4C,  //L key
            vk_m = 0x4D,  //M key
            vk_n = 0x4E,  //N key
            vk_o = 0x4F,  //O key
            vk_p = 0x50,  //P key
            vk_q = 0x51,  //Q key
            vk_r = 0x52,  //R key
            vk_s = 0x53,  //S key
            vk_t = 0x54,  //T key
            vk_u = 0x55,  //U key
            vk_v = 0x56,  //V key
            vk_w = 0x57,  //W key
            vk_x = 0x58,  //X key
            vk_y = 0x59,  //Y key
            vk_z = 0x5A,  //Z key




            vk_multiply = 0x6A,  // *
            vk_add = 0x6B,  // +
            vk_separator = 0x6C,  //Separator key
            vk_subtract = 0x6D,  // - 
            vk_decimal = 0x6E,  //.
            vk_divide = 0x6F,  // / key


            vk_oem_1 = 0xBA,  // ; :

            vk_oem_plus = 0xBB,  // = +
            vk_oem_comma = 0xBC,  // , <
            vk_oem_minus = 0xBD,  // - _
            vk_oem_period = 0xBE,  // . >

            vk_oem_2 = 0xBF,  // / ?
            vk_oem_3 = 0xC0,  // ` ~



            vk_oem_4 = 0xDB,  // [ {
            vk_oem_5 = 0xDC,  // \ |
            vk_oem_6 = 0xDD,  // ] }


            vk_oem_7 = 0xDE,  // ' "
            vk_oem_8 = 0xDf  //




        ;
        #endregion

        #region VirtualKey2
        public static int VK_LBUTTON = 0x01,  //Left mouse button
            VK_RBUTTON = 0x02,  //Right mouse button
            VK_CANCEL = 0x03,  //Control-break processing
            VK_MBUTTON = 0x04,  //Middle mouse button (three-button mouse)
            VK_BACK = 0x08,  //BACKSPACE key
            VK_TAB = 0x09,  //TAB key
            VK_CLEAR = 0x0C,  //CLEAR key
            VK_RETURN = 0x0D,  //ENTER key
            VK_SHIFT = 0x10,  //SHIFT key
            VK_CONTROL = 0x11,  //CTRL key
            VK_MENU = 0x12,  //ALT key
            VK_PAUSE = 0x13,  //PAUSE key
            VK_CAPITAL = 0x14,  //CAPS LOCK key
            VK_HANGUL = 0x15,
            VK_ESCAPE = 0x1B,  //ESC key
            VK_SPACE = 0x20,  //SPACEBAR
            VK_PRIOR = 0x21,  //PAGE UP key
            VK_NEXT = 0x22,  //PAGE DOWN key
            VK_END = 0x23,  //END key
            VK_HOME = 0x24,  //HOME key
            VK_LEFT = 0x25,  //LEFT ARROW key
            VK_UP = 0x26,  //UP ARROW key
            VK_RIGHT = 0x27,  //RIGHT ARROW key
            VK_DOWN = 0x28,  //DOWN ARROW key
            VK_SELECT = 0x29,  //SELECT key
            VK_PRINT = 0x2A,  //PRINT key
            VK_EXECUTE = 0x2B,  //EXECUTE key
            VK_SNAPSHOT = 0x2C,  //PRINT SCREEN key
            VK_INSERT = 0x2D,  //INS key
            VK_DELETE = 0x2E,  //DEL key
            VK_HELP = 0x2F,  //HELP key
            VK_0 = 0x30,  //0 key
            VK_1 = 0x31,  //1 key
            VK_2 = 0x32,  //2 key
            VK_3 = 0x33,  //3 key
            VK_4 = 0x34,  //4 key
            VK_5 = 0x35,  //5 key
            VK_6 = 0x36,  //6 key
            VK_7 = 0x37,  //7 key
            VK_8 = 0x38,  //8 key
            VK_9 = 0x39,  //9 key
            VK_A = 0x41,  //A key
            VK_B = 0x42,  //B key
            VK_C = 0x43,  //C key
            VK_D = 0x44,  //D key
            VK_E = 0x45,  //E key
            VK_F = 0x46,  //F key
            VK_G = 0x47,  //G key
            VK_H = 0x48,  //H key
            VK_I = 0x49,  //I key
            VK_J = 0x4A,  //J key
            VK_K = 0x4B,  //K key
            VK_L = 0x4C,  //L key
            VK_M = 0x4D,  //M key
            VK_N = 0x4E,  //N key
            VK_O = 0x4F,  //O key
            VK_P = 0x50,  //P key
            VK_Q = 0x51,  //Q key
            VK_R = 0x52,  //R key
            VK_S = 0x53,  //S key
            VK_T = 0x54,  //T key
            VK_U = 0x55,  //U key
            VK_V = 0x56,  //V key
            VK_W = 0x57,  //W key
            VK_X = 0x58,  //X key
            VK_Y = 0x59,  //Y key
            VK_Z = 0x5A,  //Z key
            VK_NUMPAD0 = 0x60,  //Numeric keypad 0 key
            VK_NUMPAD1 = 0x61,  //Numeric keypad 1 key
            VK_NUMPAD2 = 0x62,  //Numeric keypad 2 key
            VK_NUMPAD3 = 0x63,  //Numeric keypad 3 key
            VK_NUMPAD4 = 0x64,  //Numeric keypad 4 key
            VK_NUMPAD5 = 0x65,  //Numeric keypad 5 key
            VK_NUMPAD6 = 0x66,  //Numeric keypad 6 key
            VK_NUMPAD7 = 0x67,  //Numeric keypad 7 key
            VK_NUMPAD8 = 0x68,  //Numeric keypad 8 key
            VK_NUMPAD9 = 0x69,  //Numeric keypad 9 key
            VK_SEPARATOR = 0x6C,  //Separator key
            VK_SUBTRACT = 0x6D,  //Subtract key
            VK_DECIMAL = 0x6E,  //Decimal key
            VK_DIVIDE = 0x6F,  //Divide key
            VK_F1 = 0x70,  //F1 key
            VK_F2 = 0x71,  //F2 key
            VK_F3 = 0x72,  //F3 key
            VK_F4 = 0x73,  //F4 key
            VK_F5 = 0x74,  //F5 key
            VK_F6 = 0x75,  //F6 key
            VK_F7 = 0x76,  //F7 key
            VK_F8 = 0x77,  //F8 key
            VK_F9 = 0x78,  //F9 key
            VK_F10 = 0x79,  //F10 key
            VK_F11 = 0x7A,  //F11 key
            VK_F12 = 0x7B,  //F12 key
            VK_SCROLL = 0x91,  //SCROLL LOCK key
            VK_LSHIFT = 0xA0,  //Left SHIFT key
            VK_RSHIFT = 0xA1,  //Right SHIFT key
            VK_LCONTROL = 0xA2,  //Left CONTROL key
            VK_RCONTROL = 0xA3,  //Right CONTROL key
            VK_LMENU = 0xA4,   //Left MENU key
            VK_RMENU = 0xA5,  //Right MENU key
            VK_PLAY = 0xFA,  //Play key
            VK_ZOOM = 0xFB //Zoom key
            ;
        #endregion

        private static byte[] keyState = new byte[256];

        public static bool enter
        {
            get
            {
                return KeyboardCheck(vk_enter);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_enter, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_enter, 0, key_up, 0);
                }
            }
        }
        public static bool esc
        {
            get
            {
                return KeyboardCheck(vk_esc);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_esc, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_esc, 0, key_up, 0);
                }
            }
        }
        public static bool shift
        {
            get
            {
                return KeyboardCheck(vk_shift);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_shift, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_shift, 0, key_up, 0);
                }
            }
        }
        public static bool space
        {
            get
            {
                return KeyboardCheck(vk_space);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_space, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_space, 0, key_up, 0);
                }
            }
        }
        public static bool back
        {
            get
            {
                return KeyboardCheck(vk_back);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_back, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_back, 0, key_up, 0);
                }
            }
        }
        public static bool ctrl
        {
            get
            {
                return KeyboardCheck(vk_ctrl);
            }
            set
            {
                if (value)
                {
                    keybd_event(vk_ctrl, 0, key_down, 0);
                }
                else
                {
                    keybd_event(vk_ctrl, 0, key_up, 0);
                }
            }
        }
        public static bool hangul
        {
            get
            {
                return hangleToggle;
            }
            set
            {
                if (value != hangul)
                {
                    keybd_event(vk_hangul, 0, key_down, 0);
                    keybd_event(vk_hangul, 0, key_up, 0);
                    hangleToggle = value;
                }
            }
        }
        public static bool cap
        {
            get
            {
                return KeyboardCheckToggle(vk_cap);
            }
            set
            {
                if (value != cap)
                {
                    keybd_event(vk_cap, 0, key_down, 0);
                    keybd_event(vk_cap, 0, key_up, 0);
                }
            }
        }
        public static bool KeyCheck(int key)
        {
            return KeyboardCheck(key);
        }
        public static bool KeyCheckToggle(int key)
        {
            return KeyboardCheckToggle(key);
        }
        public static bool KeyboardCheckToggle(int key)
        {
            return (GetKeyState(key) & 0x0001) != 0;
            // GetKeyboardState(keyState);
        }
        public static bool KeyboardCheck(int key)
        {
            return (GetKeyState(key) & 0x8000) > 0;
            // GetKeyboardState(keyState);
        }
        public static void KeyPress(string text)
        {

            byte[] keycodes = ConvertKeycode(text);
            bool[] checkShiftCharacters = CheckShiftCharacter(text);
            bool[] bo_hangul = ConvertToSimpleAndIfKr(text);



            for (int i = 0; i < keycodes.Length; i++)
            {

                shift = checkShiftCharacters[i];
                if (hangul != bo_hangul[i])
                {
                    hangul = bo_hangul[i];
                    Thread.Sleep(200);
                }
                keybd_event(keycodes[i], 0, key_down, 0);
                keybd_event(keycodes[i], 0, key_up, 0);
            }
            shift = false;
            if (hangul != false)
            {
                space = true;
                space = false;

                back = true;
                back = false;

                hangul = false;
                Thread.Sleep(200);
            }
        }


        public static bool KrExists(string text)
        {
            return Array.Find(CheckKrCharacter(text), x => x == true);
        }
        public static bool[] ConvertToSimpleAndIfKr(string text)
        {
            return CheckKrCharacter(ConvertKrKey(text));
        }
        public static bool[] CheckKrCharacter(string text)
        {
            return System.Array.ConvertAll(text.ToCharArray(), x => CheckKrCharacter(x));
        }
        public static bool CheckKrCharacter(char character)
        {
            return ((character >= 0x1100) && (character <= 0x11FF))
                || ((character >= 0x3131) && (character <= 0x319E))
                || ((character >= 0xAC00) && (character <= 0xD7A3));
        }

        public static bool CheckCompletionKr(char character)
        {
            return (character >= 0xAC00) && (character <= 0xD7A3);
        }

        public static byte[] ConvertKeycode(string text)
        {
            return System.Array.ConvertAll(ConvertKrKey(text).ToCharArray(), x => ConvertKeycode(x)); 
        }
        public static byte ConvertKeycode(char character)
        {
            switch (character)
            {

                case '\n':
                    return vk_enter;

                case ';':
                case ':':
                    return vk_oem_1;
                case '/':
                case '?':
                    return vk_oem_2;
                case '`':
                case '~':
                    return vk_oem_3;
                case '[':
                case '{':
                    return vk_oem_4;
                case '\\':
                case '|':
                    return vk_oem_5;
                case ']':
                case '}':
                    return vk_oem_6;
                case '\'':
                case '"':
                    return vk_oem_7;
                case '=':
                case '+':
                    return vk_oem_plus;
                case '-':
                case '_':
                    return vk_oem_minus;
                case ',':
                case '<':
                    return vk_oem_comma;
                case '.':
                case '>':
                    return vk_oem_period;

                case ' ':
                    return vk_space;
                case '0':
                case ')':
                    return vk_0;
                case '1':
                case '!':
                    return vk_1;
                case '2':
                case '@':
                    return vk_2;
                case '3':
                case '#':
                    return vk_3;
                case '4':
                case '$':
                    return vk_4;
                case '5':
                case '%':
                    return vk_5;
                case '6':
                case '^':
                    return vk_6;
                case '7':
                case '&':
                    return vk_7;
                case '8':
                case '*':
                    return vk_8;
                case '9':
                case '(':
                    return vk_9;
                case 'a':
                case 'A':
                case 'ㅁ':
                    return vk_a;
                case 'b':
                case 'B':
                case 'ㅠ':
                    return vk_b;
                case 'c':
                case 'C':
                case 'ㅊ':
                    return vk_c;
                case 'd':
                case 'D':
                case 'ㅇ':
                    return vk_d;
                case 'e':
                case 'E':
                case 'ㄷ':
                case 'ㄸ':
                    return vk_e;
                case 'f':
                case 'F':
                case 'ㄹ':
                    return vk_f;
                case 'g':
                case 'G':
                case 'ㅎ':
                    return vk_g;
                case 'h':
                case 'H':
                case 'ㅗ':
                    return vk_h;
                case 'i':
                case 'I':
                case 'ㅑ':
                    return vk_i;
                case 'j':
                case 'J':
                case 'ㅓ':
                    return vk_j;
                case 'k':
                case 'K':
                case 'ㅏ':
                    return vk_k;
                case 'l':
                case 'L':
                case 'ㅣ':
                    return vk_l;
                case 'm':
                case 'M':
                case 'ㅡ':
                    return vk_m;
                case 'n':
                case 'N':
                case 'ㅜ':
                    return vk_n;
                case 'o':
                case 'O':
                case 'ㅐ':
                case 'ㅒ':
                    return vk_o;
                case 'p':
                case 'P':
                case 'ㅔ':
                case 'ㅖ':
                    return vk_p;
                case 'q':
                case 'Q':
                case 'ㅂ':
                case 'ㅃ':
                    return vk_q;
                case 'r':
                case 'R':
                case 'ㄱ':
                case 'ㄲ':
                    return vk_r;
                case 's':
                case 'S':
                case 'ㄴ':
                    return vk_s;
                case 't':
                case 'T':
                case 'ㅅ':
                case 'ㅆ':
                    return vk_t;
                case 'u':
                case 'U':
                case 'ㅕ':
                    return vk_u;
                case 'v':
                case 'V':
                case 'ㅍ':
                    return vk_v;
                case 'w':
                case 'W':
                case 'ㅈ':
                case 'ㅉ':
                    return vk_w;
                case 'x':
                case 'X':
                case 'ㅌ':
                    return vk_x;
                case 'y':
                case 'Y':
                case 'ㅛ':
                    return vk_y;
                case 'z':
                case 'Z':
                case 'ㅋ':
                    return vk_z;
            }
            return 0;
        }

        public static bool[] CheckShiftCharacter(string text)
        {
            return System.Array.ConvertAll(ConvertKrKey(text).ToCharArray(), x => CheckShiftCharacter(x));
        }
        public static bool CheckShiftCharacter(char character)
        {
            switch (character)
            {



                case '<':
                case '>':
                case '?':
                case '"':
                case ':':
                case '{':
                case '}':
                case '_':
                case '+':
                case '|':
                case '~':

                case ')':
                case '!':
                case '@':
                case '#':
                case '$':
                case '%':
                case '&':
                case '*':
                case '^':
                case '(':

                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'ㄸ':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'ㅒ':
                case 'P':
                case 'ㅖ':
                case 'Q':
                case 'ㅃ':
                case 'R':
                case 'ㄲ':
                case 'S':
                case 'T':
                case 'ㅆ':
                case 'U':
                case 'V':
                case 'W':
                case 'ㅉ':
                case 'X':
                case 'Y':
                case 'Z':
                    return true;
            }
            return false;
        }

        public static string ConvertKrKey(string text)
        {
            return string.Concat(System.Array.ConvertAll(text.ToCharArray(), x => ConvertKrKey(x)));
        }
        public static string ConvertKrKey(char character)
        {
            string text = "";
            if (!CheckCompletionKr(character))
            {
                text += character;
                return text;
            }
            int char_number = character - 0xAC00;
            text += krSyllableFirst[char_number / (28 * 21)];
            text += krSyllableSecond[(char_number % (28 * 21)) / 28];
            text += krSyllableThird[char_number % 28];
            return text;
        }

    }

'윈도우폼' 카테고리의 다른 글

DLL 생성 예제  (0) 2021.02.11
c# 멀티스레드 기본소스  (0) 2020.11.23
자주 쓰는 윈폼 코드 모음  (0) 2020.10.31
posted by 모카쨩
2020. 11. 23. 16:26 윈도우폼

c# 멀티스레드풀 기본소스

(2015년에 짠 코드라 그렇지 이미지처리를 CPU로 하는 병신짓은 하지말자)

using System.Collections;



public bool multi_threadpool_MC(float[,] img1f)
{
    int img1wid = img1f.GetLength(0); // 기준 이미지 너비
    int img1hei = img1f.GetLength(1); //기준 이미지 높이

    int coreNum = 64; //스레드풀 갯수 설정

    EventWaitHandle[] threadSig = new EventWaitHandle[coreNum]; //스레드풀 계산 완료 시그널
    Hashtable[] ht_t = new Hashtable[coreNum];
    for (int i = 0; i < coreNum; i++)
    {
        threadSig[i] = new EventWaitHandle(false, EventResetMode.ManualReset);//서브스레드 대기 시그널 생성
        ht_t[i] = new Hashtable(); //인자를 전달할 해쉬테이블 생성
        ht_t[i]["num"] = i;
        ht_t[i]["coreNum"] = coreNum; //인자 박싱
        ht_t[i]["threadSig"] = threadSig[i];

        ht_t[i]["img1f"] = img1f; //계산처리할 데이터
        ht_t[i]["return"] = false; //반환값

        ThreadPool.QueueUserWorkItem(image_search_MC_thread, ht_t[i]);
    }
    WaitHandle.WaitAll(threadSig); //스레드 처리 완료 대기(최대 64개)
/*
  혹은
  for (i=0; i<coreNum; i++) 
  {
   threadSig[i].WaitOne();//스레드 처리 완료 대기
  }
*/
    bool _return_t = false;
    for (int i = 0; i < core_num; i++)
    {
        _return_t = _return_t || (bool)ht_t[i]["return"];
    }
    return _return_t;
}
private static void image_search_MC_thread(object hashtable_var)
{
    Hashtable ht = (Hashtable)hashtable_var; //오브젝트 언박싱


    int num = (int)ht["num"];
    int core_num = (int)ht["coreNum"];

    float[,] img1f = (float[,])ht["img1f"]; //해시테이블 언박싱
    int img1wid = img1f.GetLength(0); //1번째 차원 길이
    int img1hei = img1f.GetLength(1); //2번째 차원 길이
    for (int i = num; i < img1wid; i += core_num) //분산처리
    {
        for (int j = 0; j < img1hei; j++)
        {
            if (i==j) // 반환된 값이 True일 경우
            {
                ht["return"] = true;
            }

        }
    }

    //ht["return"] = false;
    ((EventWaitHandle)ht["_thread_sig"]).Set();
}

 

 

심플버전

    using UnityEngine;
    using System.Collections;
    using System.Threading; //스레드 시스템을 호출
    using System; //스레드에서 계산을 위해 닷넷 시스템 호출

    public class MultiThread : MonoBehaviour
    {
        private Thread thread;
        private EventWaitHandle threadSig;
        void Awake()
        {
            threadSig = new EventWaitHandle(false, EventResetMode.ManualReset);//서브스레드 대기 시그널 생성
            thread = new Thread(SubThread); //스레드를 생성
            thread.IsBackground = true; //백그라운드에서 동작(메인스레드의 하위로 들어감)
            thread.Start(); //스레드 시작

//기다리는동안 처리될코드

            threadSig.WaitOne();//서브스레드 처리 완료 대기중
            threadSig.Reset();//수신완료 리셋
        }
        private void SubThread()
        {
            //여기에 처리시킬 코드를 넣습니다 


            threadSig.Set(); //서브스레드 종료알림
        }
    }

 

 

 

멀티스레드 기본소스

//ver 0.1.2
using UnityEngine;
using System.Collections;
using System.Threading; //스레드 시스템을 호출
using System; //스레드에서 계산을 위해 닷넷 시스템 호출

public class multi_thread : MonoBehaviour {
 private Thread[] _thread;
 private EventWaitHandle[] _thread_sig;
 private EventWaitHandle _thread_sig_main ;
 private EventWaitHandle _thread_sig_end ;
 public int _core_num = SystemInfo.processorCount*16; //코어갯수 설정(코어갯수*16)
 private int i, j, k, l; //반복문용 변수 설정
 // Use this for initialization
 void Awake() {

  _thread = new Thread[_core_num];  //코어갯수에 맞게 스레드 생성
  _thread_sig = new EventWaitHandle[_core_num];  //코어갯수에 맞게 핸들생성



  _thread_sig_main=new EventWaitHandle(false,EventResetMode.ManualReset);  //메인스레드 처리 완료 알림 시그널 생성
  _thread_sig_end=new EventWaitHandle(false,EventResetMode.ManualReset);  //메인스레드 수신완료 시그널 생성
  for(i=0;i<_core_num;i++)
  {
   _thread_sig[i]=new EventWaitHandle(false,EventResetMode.ManualReset);//서브스레드 대기 시그널 생성
   _thread[i] = new Thread (subthread); //스레드를 생성
   _thread[i].IsBackground = true; //백그라운드에서 동작(메인스레드의 하위로 들어감)
   //_thread[i].Priority = ThreadPriority.Highest;  //백그라운드 스레드의 우선순위를 높음으로 변경(높을수록 빠름)
   //_thread[i].Priority = ThreadPriority.AboveNormal;  //백그라운드 스레드의 우선순위를 약간 높음으로 변경
   //_thread[i].Priority = ThreadPriority.Normal;  //백그라운드 스레드의 우선순위를 보통으로 변경
   _thread[i].Priority = ThreadPriority.BelowNormal;  //백그라운드 스레드의 우선순위를 약간 낮음으로 변경
   //_thread[i].Priority = ThreadPriority.Lowest;  //백그라운드 스레드의 우선순위를 낮음으로 변경(낮을수록 느림)
   _thread[i].Start (i); //스레드 시작
  }
 }
 // Update is called once per frame
 void LateUpdate ()   
 {
  _thread_sig_end.Reset();//수신완료 리셋
  _thread_sig_main.Set();//메인스레드 처리 완료 알림(서브스레드 시작)
  for (i=0; i<_core_num; i++) 
  {
   _thread_sig[i].WaitOne();//서브스레드 처리 완료 대기중
  }
  _thread_sig_main.Reset();//메인스레드 처리중 알림
  _thread_sig_end.Set();//메인스레드 수신 완료 알림
 }
 private void subthread(object _thread_num)
 {
  int _t_thread_num=(int)_thread_num; //스레드 번호 인자를 넘겨받은것을 언박싱
  
  while(true)
  {
   _thread_sig_main.WaitOne(); //메인스레드가 종료할때까지 대기

   /*
   여기에 처리시킬 코드를 넣습니다 
   예시
   for (int i=_t_thread_num; i<100000; i+=_core_num) 
   {
    _t += i;
   }
    */


   _thread_sig[_t_thread_num].Set(); //서브스레드 종료알림
   _thread_sig_end.WaitOne(); //메인스레드가 수신했는지
   _thread_sig[_t_thread_num].Reset(); //서브스레드 재가동 알림
 }
}

 

 

일반함수처럼 쓸수있는 스레드. (태스크)

test(); 같은식으로 호출해주면 됨

비동기로 작동한다

주의점은 유니티가 종료되어도 계속 작동해서 가급적 코루틴을 쓰자

async void test()
{
    await Task.Run(() => {
        while (true)
        {
            System.Threading.Thread.Sleep(1000);
            Debug.Log($"테스트 {System.DateTime.Now}");
        }
    });
}

 

 

태스크, 코루틴이랑 비슷하지만 유니티가 종료되어도 계속 작동한다

유니티 함수계열은 안 된다(디버그로그는 된다)

var t = System.Threading.Tasks.Task.Run(() => {
    //System.Threading.Tasks.Task.Delay(10000).Wait();
    System.Threading.Thread.Sleep(10000);
    Debug.Log("Task ended delay...");
});

 

 

반환값이 있는 태스크

주의점은 result호출시 계산이 끝날때까지 기다린다

Debug.Log($"Start {System.DateTime.Now}");

var t = System.Threading.Tasks.Task.Run(() => {
    System.Threading.Thread.Sleep(10000);
    Debug.Log($"Task ended delay... {System.DateTime.Now}");
});



var t2 = System.Threading.Tasks.Task.Run(() => {
    System.Threading.Thread.Sleep(3000);
    return System.DateTime.Now;
});
Debug.Log($"Task2 ended delay...{t2.Result}"); //result구하면서 wait가 걸린다

'윈도우폼' 카테고리의 다른 글

윈폼 키보드마우스  (0) 2021.01.17
자주 쓰는 윈폼 코드 모음  (0) 2020.10.31
c# 윈도우 폼  (0) 2018.01.28
posted by 모카쨩

  • total
  • today
  • yesterday

Recent Post

저사양 유저용 블로그 진입