예외, 에러 해결

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

코드 작성 후 실행 중 전혀 문제가 없어보이던(라고 생각한) 부분에서 예외가 발생했다.

예외 발생: 'System.InvalidOperationException'(mscorlib.dll) 컬렉션이 수정되었습니다. 열거 작업이 실행되지 않을 수도 있습니다.

찾아보니 내 경우는 Collection을 foreach로 접근 중일때 Remove나 Add 등의 동작으로 Collection을 변경하려고 했기 때문에 발생하는 예외라고 한다.

ObservableCollection<string> tempCollection = new ObservableCollection<string>();

foreach (string item in tempCollection) 
{
    ...
}

이 때의 해결 방법은

1. foreach가 아닌 for문으로 순회한다.
2. 해당 Collection의 복사본을 만든다. (ToList())

2번의 방법으로 해결했다.

foreach (var item in tempCollection.ToList()) 
{
    ...
}

또는 복사본을 이렇게도 만들 수 있겠다.

ObservableCollection<string> tempCollection = new ObservableCollection<string>();

ObservableCollection<string> tempCopyCollection = new ObservableCollection<string>(tempCollection);

4. 결과

문제 해결

ActiveDocument가 PartDocument일때 Axis System의 이름을 변경하거나 Publication을 추가, 제거하는 방법. 이 글에서 실행중인 CATIA를 얻어온 후 시작한다.

2. 개발환경

• Visual Studio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)
• CATIA V5

3. 내용

3-1. Selection

실행 중인 CATIA에서 열려 있는 PartDocument에서 Product를 찾는다.

PartDocument partDocument = (PartDocument)CATIA_Define.oCATIA.ActiveDocument;
Product product = partDocument.Product;

Selection을 Clear하고 시작한다.

Selection catiaSelect = partDocument.Selection;
catiaSelect.Clear();

Selection에서 사용할 수 있는 메소드로 SelectElement2, SelectElement3, SelectElement4 등이 있다.

2는 하나의 객체를 선택할 수 있다. 3은 여러 객체를 선택할 수 있다. 4는 활성화 되지 않은 Document에서 여러 객체를 선택할 수 있다.

하나의 객체를 선택할 것이기 때문에 SelectElement2를 사용한다. SelectElement2의 인자는 다음과 같다. SelectElement2(Array iFilterType, ref string iMessage, bool iObjectSelectionBeforeCommandUsePossibility)

object[] filter = new object[1];
object selectElement;
selectElement = catiaSelect.SelectElement2(filter, "Select Axis System in which you want to add", false);

SelectElement2가 실행되면 CATIA에서 객체를 선택할 수 있는 상태가 된다.

설명을 위해 Axis System을 선택하겠다고 적어두었지만 Axis System외에도 선택이 되기 때문에 선택된 객체가 어떤 타입인지 구분할 수 있어야 한다.

if (selectElement != null)
{
        if (Information.TypeName(catiaSelect.Item(1).Value).Equals("AxisSystem"))
        {
            .
            .
            .
        }
   }

Selection의 첫 번째 item.Value의 TypeName이 AxisSystem이라는 것을 확인했다면 AxisSystem 타입의 객체에 넣어줄 수 있다.

AxisSystem axisSystem = catiaSelect.Item(1).Value;

axisSystem에서 .get_Name()으로 Feature Name을 얻을 수 있고, .set_Name()으로 Feature Name을 변경할 수 있다.

3-2. Publication 추가

Catia의 Tools>Publication에서 Axis System과 연결된 Publication을 추가할 수 있다.

이때 추가된 Publication의 이름은 연결된 Axis System의 이름과 같다. Axis System의 이름을 변경해도 연결은 끊어지지 않는다. 변경된 Axis System의 이름이 Element에 반영되어있기 때문이다.

Catia의 Visual Basic help의 내용에 따르면 CreateReferenceFromName은 이름으로 Reference를 생성하는 메서드이다. 들어가는 인자의 내용은 경로인데 "/"를 사용하여 구성 요소를 분리하고, 제품 경로는 "/!"을 사용하여 분리한다. 제품 경로에서 매개변수를 분리하려면 ""를 사용하면 된다고 한다. 즉 /! 뒤의 문자열이 Publication의 이름이 된다.

Product product = partDocument.Product;

Reference reference = product.CreateReferenceFromName(product.get_Name() + "/!" + "Axis System.1");

Publications publications = product.Publications;
publications.Add("Axis System.1");

설명을 위해 간단한 구조의 PartDocument로 작업했기 때문에 CreateRefrenceFromName에 작성한 경로를 product.get_Name() + "/!" + "Axis System.1" 이라고 작성했는데 이 부분은 쓰는 사람마다 다 다를 것이다.

3-3. Publication 추가

Publication의 이름을 알면 Publication을 제거할 수 있다. 또는 Publication에 연결된 Axis System의 이름을 알면 Publication을 제거할 수 있다.

다음의 코드는 Publications의 개수만큼 for문을 반복하여 Publication에 연결된 Axis System의 이름에 "Axis System.1"이 포함되어 있으면 그 Publication을 Publications에서 Remove하는 코드이다.

Publications publications = product.Publications;

for (int i = 1; i <= publications.Count; i++)
{
    Publication publication = publications.Item(i);
    Reference reference = (Reference)publication.Valuation;

    if (reference.DisplayName.IndexOf("Axis System.1") > 0)
    {
        publications.Remove(publications.Item(i).get_Name());
    }
}

4. 생각해보기

Catia Automation 관련 글은 내가 잘 알아서 쓴다기보다는 정말로 안까먹으려고 작성한다. 구글링을 해도 특히 Automation, Macro 관련해서는 한글로 된 글이 별로 없거나...영어권 자료도 빨라야 19년, 22년...정도여서 난감하다. 하지만 비주얼 베이직으로 작성된 코드를 C#으로 바꾸는 과정은 흥미롭다. Catia에 대해서도 더 알고싶다. 익숙해지는 그날까지 화이팅~~ 혹시나 이 글을 읽었는데 잘 못 적은 어휘나 내용이 있다면 이해와 댓글을 부탁드립니다...

5. 참조

Selection 관련

• https://www.scripting4v5.com/additional-articles/catia-macro-selection/
• https://catiavbmacro.com/2018/08/26/catia-macro-selection/#google_vignette
• https://www.eng-tips.com/viewthread.cfm?qid=383495

Publications, Publication 관련

• https://catiavbmacro.com/2018/08/27/delete-catia-publication-free-macro-code/
• https://www.eng-tips.com/viewthread.cfm?qid=443869

C#을 사용해서 Catia V5용 매크로/프로그램을 MVVM 구조로 작성하기. CATIA 열기 또는 실행 방법

2. 개발환경

• Visual Studio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

MVVM 패턴 구조의 신규 프로젝트를 구성한 후 Catia 관련 작업을 할 class를 새로 추가한다. static 또는 singleton으로...나는 singleton으로 만들어 사용하기로 했다.

    public class CatiaDefine
    {
        private static CATIA_Define _Instance = null;

        public static CATIA_Define GetInstance()
        {
            if (_Instance == null)
            {
                _Instance = new CATIA_Define();
            }
            return _Instance;
        }
    }

INFITF CATIA Application에 대한 Typelib 라이브러리를 추가한다.

CATIA V5 Infinterfaces Object Library

참조>참조 추가

catia를 변수로 선언한다.

public INFITF.Application catia;

GetActiveObject는 이미 CATIA가 실행 중인 상태에서의 인스턴스를 가져온다.

catia = (INFITF.Application)System.Runtime.InteropServices.Marshal.GetActiveObject("CATIA.Application");

CreateInstance는 새 인스턴스를 생성한다.

catia = (INFITF.Application)Activator.CreateInstance(Type.GetTypeFromProgID("CATIA.Application"));

메서드로 만들어 컨트롤의 동작이 이루어질 때 실행하게 할 수 있다.

        public void CatiaApp()
        {
            try
            {
                catia = (INFITF.Application)System.Runtime.InteropServices.Marshal.GetActiveObject("CATIA.Application");
            }
            catch (Exception ex)
            {
                catia = (INFITF.Application)Activator.CreateInstance(Type.GetTypeFromProgID("CATIA.Application"));
                catia.Visible = true;
                Console.WriteLine(ex.Message);
            }
        }

이렇게 작성하면 try에서 실행중인 CATIA 인스턴스를 못 가져왔을 경우 catch에서 새로 CATIA를 실행하게 된다. 다만 이미 CATIA가 실행 중일 때 새 CATIA를 실행하는 것이므로 계속해서 새 CATIA를 띄우는 문제가 생긴다.

4. 재부팅 또는 재실행

처음 코드를 작성했을 때

catia = (INFITF.Application)System.Runtime.InteropServices.Marshal.GetActiveObject("CATIA.Application");

이 부분에서 catia = null 상태였다. 인스턴스를 가져오지 못한 것인데 코드의 문제는 아니었고 Visual Studio를 껐다가 다시 켜보거나 컴퓨터의 재부팅을 하면 해결되는 문제였다.

5. 참조

• https://stackoverflow.com/questions/40620334/use-c-sharp-for-catia-v5-automation
• http://www.catia-forum.cz/forum/topic.php?topic_id=47

지난 글에 이어서 Polyline을 그린 후 클릭 이벤트를 적용하는 방법에 대해 찾아보았고 Microsoft.Xaml.Behaviors.Wpf를 사용하기로 했다. 더불어 이 글의 댓글에서 지적해주셨던 것 처럼 Behavior의 정석 작성법은 ViewModel에서 작성한 Command를 호출하는 것이 아니라 Behavior<>를 상속받아 OnAttach() 와 OnDetaching()를 작성하는 것이 올바른 방법이기에 이 또한 적용했다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.8)

3. 내용

3-1. 환경 설정

NuGet 패키지 관리에서 Microsoft.Xaml.Behaviors.Wpf 설치

Behaviors 폴더 생성한 후 MouseBehavior.cs 파일 생성하기. 폴더를 따로 안만들어도 상관 없다. local:로 접근하면 되니까...

XAML에 네임스페이스를 작성한다. 나는 local이 아니라 bh로 Behavior에 접근하려고 한다.

3-2. Behavior 작성

내가 Behavior를 작성하는 이유는 Polyline에는 Button처럼 마우스 왼쪽 클릭을 했을 때 Command를 적용할 방법이 없기 때문이다. 최대한 MVVM 패턴을 준수하며 작성하고 싶었기 때문에 코드 비하인드를 사용하지 않고 싶었다.

3-2-1. MouseBehavior.cs는 Behavior를 상속 받는다.

: Behavior<T>에서 T는 Behavior를 적용할 Control이 된다. Polyline에 적용하기 때문에 : Behavior<Polyline>이 된다.

3-2-2. DependencyProperty를 작성한다.

        public static readonly DependencyProperty MouseXProperty = DependencyProperty.Register(
            "MouseX", typeof(double), typeof(MouseBehavior), new PropertyMetadata(default(double)));

        public static readonly DependencyProperty MouseYProperty = DependencyProperty.Register(
            "MouseY", typeof(double), typeof(MouseBehavior), new PropertyMetadata(default(double)));

MouseX, MouseY 라는 DependencyProperty를 추가하면 XAML의 Behavior 작성시 속성으로 사용할 수 있게 된다.

3-2-3. OnAttached()와 OnDetaching()의 작성

코드 비하인드에서 Mouse 동작과 관련한 이벤트핸들러를 추가할 때에는 +=연산자를, 삭제할 때에는 -=를 사용한 적이 있는데 그것과 같다.

        protected override void OnAttached()
        {
            AssociatedObject.MouseLeftButtonDown += AssociatedObjectOnMouseLeftButtonDown;
        }
        protected override void OnDetaching()
        {
            AssociatedObject.MouseLeftButtonDown -= AssociatedObjectOnMouseLeftButtonDown;
        }

이벤트핸들러의 동작을 작성한다. MouseLeftButtonDown 동작이 실행되면 현재 마우스 Position을 가져온다.

        private void AssociatedObjectOnMouseLeftButtonDown(object sender, MouseEventArgs mouseEventArgs)
        {
            var mousePoint = mouseEventArgs.GetPosition(AssociatedObject);
            MouseX = mousePoint.X;
            MouseY = mousePoint.Y;
        }

3-3. ViewModel 작성

지난 글에서의 ViewModel에 바인딩 할 PanelX, PanelY를 추가한다.

        private double _panelX;
        public double PanelX
        {
            get { return _panelX; }
            set
            {
                _panelX = value;
                OnPropertyChanged(nameof(PanelX));
            }
        }

        private double _panelY;
        public double PanelY
        {
            get { return _panelY; }
            set
            {
                _panelY = value;
                OnPropertyChanged(nameof(PanelY));
            }
        }

3-4. XAML 작성

지난 글에서의 Xaml에 Behavior를 추가한다.

<Polyline Points="{Binding}" Stroke="Red" Fill="Transparent" StrokeThickness="2" Cursor="Hand">
    <i:Interaction.Behaviors>
        <bh:MouseBehavior MouseX="{Binding DataContext.PanelX, RelativeSource={RelativeSource AncestorType=ItemsControl}, Mode=OneWayToSource}"
                          MouseY="{Binding DataContext.PanelY, RelativeSource={RelativeSource AncestorType=ItemsControl}, Mode=OneWayToSource}" />
    </i:Interaction.Behaviors>
</Polyline>

Mouse의 Position값을 알기 위해 작성한 PanelX, PanelY의 값을 확인하려면 상단에 TextBlock을 추가한다.

        <Grid Grid.Row="0" VerticalAlignment="Bottom">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">
                <TextBlock Text="{Binding PanelX, StringFormat='X={0} '}"/>
                <TextBlock Text="{Binding PanelY, StringFormat='Y={0}'}"/>
            </StackPanel>
        </Grid>

4. 결과

Polyline의 Fill을 Transparent로 설정하고 Cursor를 Hand로 설정하여 마치 Button을 클릭하는 느낌이 됐다. Polyline이 그려진 부분을 클릭하면 위에 배치한 TextBlock에 바인딩 된 X값과 Y값을 확인할 수 있다.

5. 오류 해결하기

처음엔 Behavior작성 시 PanelX, PanelY를 바인딩 할 때 아래와 같이 작성했었는데

<bh:MouseBehavior MouseX="{Binding Path=DataContext.PanelX, Mode=OneWayToSource, RelativeSource={RelativeSource AncestorType={x:Type Polyline}}}"
                  MouseY="{Binding Path=DataContext.PanelY, Mode=OneWayToSource, RelativeSource={RelativeSource AncestorType={x:Type Polyline}}}" />

다음과 같은 에러가 발생했다.

System.Windows.Data Error: 40 : BindingExpression path error: 'PanelX' property not found on 'object' ''PointCollection' (HashCode=30046694)'. BindingExpression:Path=DataContext.PanelX; DataItem='Polyline' (Name=''); target element is 'MouseBehavior' (HashCode=11318800); target property is 'MouseX' (type 'Double')

Console을 보면 Polyline이 그려진 개 수만큼 PanelX, PanelY가 짝으로 에러가 발생하는 것을 알 수 있다.

찾아본 결과 stack overflow에서 해결 방법을 찾을 수 있었다. DataContext의 바인딩 순서가 문제였던 듯 하여 본문의 내용과 같은 순서로 작성했더니 에러가 해결 되었다.

<bh:MouseBehavior MouseX="{Binding DataContext.PanelX, RelativeSource={RelativeSource AncestorType=ItemsControl}, Mode=OneWayToSource}"
                  MouseY="{Binding DataContext.PanelY, RelativeSource={RelativeSource AncestorType=ItemsControl}, Mode=OneWayToSource}" />

사실 실행을 했을 때는 문제가 없어 보이는데 어쨌든 콘솔에 출력된 에러라면 해결해야하는 것이니까...

6. 참조

Behavior 작성

• https://kaki104.tistory.com/841
• https://m.blog.naver.com/vactorman/221176866353
• https://stackoverflow.com/questions/617312/what-is-a-dependency-property
• https://kaki104.tistory.com/563

에러 해결

• https://stackoverflow.com/questions/30508649/system-windows-data-error-40-bindingexpression-path-error

이미지 처리 할 일이 생겨서... OpenCVSharp 사용법을 찾던 중 기억해둘 내용을 작성한다.

2. 환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.8)

3. 내용

1. 프로젝트 생성 및 환경 설정

1-1. 프로젝트 생성

WPF 앱(.NET Framework)로 프로젝트를 생성한다. 이때 프레임워크는 4.8 이상이어야 한다. 이유는 WpfExtensions를 설치해야 하는데, 아래 콘솔 내용에 따르면 4.8이상부터 지원하기 때문이다. 아래 이미지는 프레임워크 4.7.2에서 WpfExtensions를 설치하려고 했을 때 콘솔에 출력되는 에러 메시지이다.

1-2. 도구>NuGet 패키지 관리자>솔루션용 NuGet 패키지 관리...

OpenCV...를 검색해서 OpenCVSharp4, OpenCVSharp4.runtime.win, OpenCVSharp.WpfExtensions를 설치한다. OpenCVSharp4.runtime.win은 Windows에서 작동하기 위한 내부 구현 패키지이고 OpenCVSharp.WpfExtensions는 WPF에서 사용하는 확장 라이브러리이다.

1-3. MVVM 패턴으로 프로젝트 구조 구성

이 글 참고

2. Control 배치

2-1. WPF Control 배치

Grid를 나눠서 위에는 이미지를 업로드하는 버튼과 없애는 버튼을 배치하고 아래에는 이미지소스를 바인딩할 이미지 컨트롤을 배치한다. 이미지 없애는 버튼은 그렇게 중요하지 않다...

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="50"/>
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <Grid Grid.Row="0">
            <StackPanel Orientation="Horizontal">
                <Button Command="{Binding UploadImageCommand}" Cursor="Hand" Content="UploadImage" Width="100" Margin="10,10,10,10"/>
                <Button Command="{Binding ClearImageCommand}" Cursor="Hand" Content="Clean" Width="70" Margin="10,10,10,10" />
            </StackPanel>
        </Grid>

        <Grid Grid.Row="1" Margin="10,10,10,10">
            <Image Source="{Binding ImageSource}" />
        </Grid>
    </Grid>

2-2. ViewModel에서 Command 작성

xaml의 버튼과 이미지에 바인딩 될 Command를 만들어준다. UploadImage 버튼을 누르면 파일을 선택할 다이얼로그를 띄우게 한다.

        private BitmapImage _ImageSource;
        public BitmapImage ImageSource
        {
            get { return _ImageSource; }
            set
            {
                _ImageSource = value;
                OnPropertyChanged(nameof(ImageSource));
            }
        }

        public ICommand UploadImageCommand { get; private set; }
        public ICommand ClearImageCommand { get; private set; }

        public MainWindowViewModel() 
        {
            UploadImageCommand = new RelayCommand(UploadImage);
            ClearImageCommand = new RelayCommand(ClearImage);
        }

        private void UploadImage()
        {
            Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog();
            openFileDialog.Filter = "Image files (*.jpg, *.jpeg, *.png) | *.jpg; *.jpeg; *.png";

            if (openFileDialog.ShowDialog() == true)
            {
                string imagePath = openFileDialog.FileName;

                ImageSource = new BitmapImage(new Uri(imagePath));

            }
        }

        private void ClearImage()
        {
            ImageSource = null;
        }

예제에서 사용할 이미지는 FreePik에서 다운로드 받은 무료 이미지이다.

이미지를 업로드하면 이런 화면이 된다.

3. OpenCVSharp

3-1. InRange

InRange는 사용자 지정 Scalar범위 픽셀을 추출한다. Scalar(B, G, R) 어두운 색에서-밝은 색까지의 범위 안에서 찾는다.

Cv2.InRange(src, new Scalar(0, 125, 125), new Scalar(100, 255, 255), edge);

new Scalar(0, 125, 125), new Scalar(100, 255, 255)는 다음의 범위이다.

3-2. FindContours, DrawContours

Cv2.FindContours(edge, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxTC89KCOS);

List<OpenCvSharp.Point[]> new_contours = new 
List<OpenCvSharp.Point[]>();
foreach (OpenCvSharp.Point[] p in contours)
{
    double length = Cv2.ArcLength(p, true);
    if (length > 100)
    {
        new_contours.Add(p);
    }
}

Cv2.DrawContours(dst, new_contours, -1, new Scalar(0, 0, 255), 2, LineTypes.AntiAlias, null, 1);

3-3. ImShow와 WpfExtensions.BitmapSourceConverter

Cv2.ImShow("dst", dst);

WPF의 ImageSource에 바인딩하려면 Mat -> BitmapImage로 바꿀 필요가 있다. 이 때 사용하는 것이 WpfExtensions이다.

WpfExtensions에서 사용할 수 있는 BitmapSourceConverter는 ToBitmapSource라는 Mat -> BitmapSource 메서드가 있다. BitmapSource로 바뀐 dst 데이터를 다시 BitmapImage로 바꿔주는 작업이 필요하다.

BitmapSource bitmapSource = OpenCvSharp.WpfExtensions.BitmapSourceConverter.ToBitmapSource(dst); // Mat to BitmapSource
ImageSource = ConvertBitmapSourceToBitmapImage(bitmapSource); //BitmapSource to BitmapImage

ConvertBitmapSourceToBitmapImage를 작성한다.

        private BitmapImage ConvertBitmapSourceToBitmapImage(BitmapSource bitmapSource)
        {
            if (!(bitmapSource is BitmapImage bitmapImage))
            {
                bitmapImage = new BitmapImage();

                BmpBitmapEncoder encoder = new BmpBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(bitmapSource));

                using (MemoryStream memoryStream = new MemoryStream())
                {
                    encoder.Save(memoryStream);
                    memoryStream.Position = 0;

                    bitmapImage.BeginInit();
                    bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
                    bitmapImage.StreamSource = memoryStream;
                    bitmapImage.EndInit();
                }
            }

            return bitmapImage;
        }

4. GetContour 메서드 작성

        private void GetContour(string imagePath)
        {
            Mat src = new Mat(imagePath); 
            Mat edge = new Mat(); 
            Mat dst = src.Clone();

            OpenCvSharp.Point[][] contours;
            HierarchyIndex[] hierarchy;

            Cv2.InRange(src, new Scalar(0, 125, 125), new Scalar(100, 255, 255), edge); //사용자 지정 Scalar범위 픽셀 추출 Scalar(B, G, R) 어두운 색에서-밝은 색까지의 범위 안에서 찾는다.
            Cv2.FindContours(edge, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxTC89KCOS); //Cv2.FindContours(원본 배열, 검출된 윤곽선, 계층 구조, 검색 방법, 근사 방법, 오프셋)

            List<OpenCvSharp.Point[]> new_contours = new List<OpenCvSharp.Point[]>();
            foreach (OpenCvSharp.Point[] p in contours)
            {
                double length = Cv2.ArcLength(p, true);
                if (length > 100)
                {
                    new_contours.Add(p);
                }
            }

            Cv2.DrawContours(dst, new_contours, -1, new Scalar(0, 0, 255), 2, LineTypes.AntiAlias, null, 1);

            BitmapSource bitmapSource = OpenCvSharp.WpfExtensions.BitmapSourceConverter.ToBitmapSource(dst); // Mat to BitmapSource
            ImageSource = ConvertBitmapSourceToBitmapImage(bitmapSource); //BitmapSource to BitmapImage

            Cv2.ImShow("dst", dst);
            Cv2.WaitKey(0); //시간 대기 함수의 값을 0으로 두어 키 입력이 있을때 까지 유지
        }

UploadeImage()에 GetContour()를 추가한다.

          private void UploadImage()
        {
            Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog();
            openFileDialog.Filter = "Image files (*.jpg, *.jpeg, *.png) | *.jpg; *.jpeg; *.png";

            if (openFileDialog.ShowDialog() == true)
            {
                string imagePath = openFileDialog.FileName;

                ImageSource = new BitmapImage(new Uri(imagePath));

                GetContour(imagePath);
            }
        }

4. 결과

실행했을 때 MainWindow의 상태이다. Mat 형식 데이터를 BitmapImage로 변환하여 Image에 바인딩했기 때문에 윤곽선이 검출된 상태의 이미지가 보인다. new Scalar(0, 125, 125)에서 new Scalar(100, 255, 255)까지의 색 범위인 윤곽선을 찾아 new Scalar(0, 0, 255) 색으로 선을 그리도록 했기 때문에 첫 번째 줄의 노란색 사각형과 맨 아래 줄의 노란색 삼각형에 빨간 윤곽선이 그려진 것을 확인할 수 있다. .ImShow로 띄운 window이다. 이미지의 원본사이즈 크기로 window가 생성되기 때문에 작게 보려면 resize가 필요할 것이다.

아래는 Console.WriteLine("new_contours count : " + new_contours.Count); 를 추가 작성하여 콘솔로 new_contours의 count를 출력한건데 그려진 윤곽선의 개 수를 확인할 수 있다.

5. 참조

• https://www.nuget.org/packages/OpenCvSharp4.runtime.win
• https://www.nuget.org/packages/OpenCvSharp4.WpfExtensions
• https://076923.github.io/posts/C-opencv4-16/
• https://redrainkim.github.io/opencvsharp/opencvsharp-study-10/
• https://shalchoong.tistory.com/37

6. 보완할 점

예제로 사용한 이미지는 깔끔하게 떨어지는 테두리를 갖고있기 때문에 윤곽선도 예쁘게 그려졌지만 복잡한 형상의 이미지의 윤곽선을 그리려고하면 지저분하게 보인다. 그럴땐 블러나 팽창, 침식 등의 메서드를 추가 적용하여 깔끔하게 그릴 수 있도록 처리하는 듯 하다. 윤곽선을 그리려고 OpenCVSharp 사용법을 알아본건 아니고 인식된 형태에 이벤트를 걸 수 있는 방법을 찾고있다. 되도록 MVVM 패턴을 준수하는 방식으로 찾아보려고 한다.

1. 배경

이 글에서 동적으로 Key가 추가되는 구조의 Json Object를 역직렬화하는 방법에 대한 내용을 작성했는데 여기에 Custom JsonConverter를 작성하는 내용을 추가 작성한다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

다음과 같은 Json Object가 존재한다.

{
    "FirstName" : "James",
    "LastName" : "Newton-King",
    "Temps" : {
        "Age" : "38",
        "Adress_1" : {
            "PhoneNumber" : "000-0000-0000", 
            "FAX" : "000-000-0000"
        },
        "Adress_2" : {
            "PhoneNumber" : "111-1111-1111", 
            "FAX" : "111-111-1111"
        }
    }
}

이대로만 Class를 만들면 될 것 같지만 문제는 Temps 안의 Address_로 시작하는 Key는 Address_1 하나일 수도 있고 _2, _3...등 여러 개가 될 수도 있다.

        "Adress_1" : {
            "PhoneNumber" : "000-0000-0000", 
            "FAX" : "000-000-0000"
        },
        "Adress_2" : {
            "PhoneNumber" : "111-1111-1111", 
            "FAX" : "111-111-1111"
        },
        "Adress_3" : {
            "PhoneNumber" : "222-2222-2222", 
            "FAX" : "222-222-2222"
        }
        .
        .
        .

그럴때 class는 다음과 같이 작성하고

        public class Employee
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public Temp Temps { get; set; }
        }

        public class Temp {
            public string Age { get; set; }
            public Dictionary<string, Address> Address { get; set; }
        }

        public class Address
        {
            public string PhoneNumber { get; set; }
            public string FAX { get; set; }
        }

JsonConverter를 작성한다. Json 문서의 이름 구조가 Address_ 일 것을 염두에 두고 작성한다.

ReadJson에서 Json Object의 Property 중 이름이 Address_로 시작하는 것을 찾아서 Key와 Value를 Add한다.

                foreach (var property in jObject.Properties())
                {
                    if (property.Name.StartsWith("Adress_"))
                    {
                        var propertyName = property.Value.ToObject<Address>();
                        temp.Address.Add(property.Name, propertyName);
                    }
                }

JsonConverter를 Dictionary Roles 위에 추가한다.

4. 결과

Temps안의 Address Count = 2

하나씩 살펴보면 Address_1, Address_2가 담긴 것을 확인할 수 있다.

5. 참조

• https://www.newtonsoft.com/json/help/html/CustomJsonConverter.htm
• https://stackoverflow.com/questions/17721755/parsing-dynamic-json-string-into-string-in-c-sharp-using-json-net
• https://github.com/dotliquid/dotliquid/issues/223

REST API로 URL을 요청하여 JSON을 반환 받으면 해당 JSON 구조대로 클래스를 만들어두고 역직렬화하여 값을 받게 되었다. 그런데 JSON 문서를 살펴보니 key의 이름이 동적으로 바뀌는 경우가 있었다. Newtonsoft.Json 라이브러리를 사용하는데 Dictionary를 사용하면 된다고 한다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

문서에 설명된 내용을 보면 api를 요청하여 받은 결과인 Json의 내용이 다음과 같다고 할때.

{
  "key" : "value",
  "key_value" : {
      "kv_1" : "abc",
      "kv_2" : "def"
  }
}

위의 Json을 class로 표현한다면 아래와 같이 만들게 될 것이다.

public class Temp 
{
  public string key { get; set; }
  public List<KeyValue> key_value { get; set; }
}

public class KeyValue 
{
  public string kv_1 { get; set; }
  public string kv_2 { get; set; }
}

하지만 응답 결과에 따라 kv_3, kv_4 ... 이렇게 key가 늘어날 수 있다. 이럴땐 List가 아니라 Dictionary를 사용한다.

public class Temp
{
  public string key { get; set; }
  public Dictionary<string, string> key_value { get; set; }
}

string 형태의 json 내용을 역직렬화 하여 Temp 객체에 담을 수 있다.

string str = "{\"key\":\"value\",\"key_value\":{\"kv_1\":\"abc\",\"kv_2\":\"def\"}}";
Temp temp = JsonConvert.DeserializeObject<Temp>(str);

4. 결과

key_value가 Dictionary 형태로 담긴 것을 확인할 수 있다.

xaml에서 MultiDataTrigger의 Condition 작성 중 Null, 공백을 체크해야 할 일이 생겼다. 처음엔 Value 값으로 {x:Null}을 작성하면 되려나 했는데 작동하지 않았다. Converter를 작성할까 하다가 더 찾아봤더니 네임스페이스를 추가하여 Value에서 공백을 체크할 수 있는 방법이 있었다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. 네임스페이스 작성

    xmlns:sys="clr-namespace:System;assembly=mscorlib"

2. xaml 작성

        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <TextBlock Text="값이 없으면 글씨 색이 빨강이 된다." />

            <StackPanel Orientation="Horizontal">
                <Label Content=" 값 : " />
                <TextBox x:Name="TextBox1" Text="기본값" VerticalContentAlignment="Center" Width="100"/>
            </StackPanel>
        </StackPanel>

3. TextBlock에 Style DataTrigger 작성

DataTrigger Binding은 ElementName에 TextBox의 x:Name을 작성하고 Value는 {x:Static sys:String.Empty}를 작성하여 문자열이 공백일 때를 체크한다.

        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <TextBlock Text="값이 없으면 글씨 색이 빨강이 된다.">
                <TextBlock.Style>
                    <Style TargetType="TextBlock">
                        <Style.Triggers>
                            <DataTrigger Binding="{Binding ElementName=TextBox1, Path=Text}" Value="{x:Static sys:String.Empty}">
                                <Setter Property="Foreground" Value="Red"/>
                            </DataTrigger>
                        </Style.Triggers>
                    </Style>
                </TextBlock.Style>
            </TextBlock>

            <StackPanel Orientation="Horizontal">
                <Label Content=" 값 : " />
                <TextBox x:Name="TextBox1" Text="기본값" VerticalContentAlignment="Center" Width="100"/>
            </StackPanel>
        </StackPanel>

4. 결과

TextBox에 입력된 값이 없으면 TextBlock의 글씨 색이 변한다. 예제는 DataTrigger를 사용했는데 MultiDataTrigger의 Condition작성 시에도 사용 가능하다.

5. 참조

• https://learn.microsoft.com/ko-kr/dotnet/desktop/xaml-services/types-for-primitives
• https://stackoverflow.com/questions/19236137/datatrigger-on-empty-string

기본 DatePicker는 날짜까지 선택이 가능하다. 구체적인 날짜까지 선택하지 않고 년/월만 선택할 수 있는 DatePicker를 만들기 위해 열심히 구글 검색을 해본 결과 DatePikcer를 새로 정의해서 사용하는 방법을 StackOverflow에서 찾을 수 있었다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. DatePickerCalendar.cs 추가

2. DataPickerCalendar.cs에 내용 작성

    public class DatePickerCalendar
    {
        public static readonly DependencyProperty IsMonthYearProperty =
            DependencyProperty.RegisterAttached("IsMonthYear", typeof(bool), typeof(DatePickerCalendar),
                                                new PropertyMetadata(OnIsMonthYearChanged));
   
        public static bool GetIsMonthYear(DependencyObject dobj)
        {
            return (bool)dobj.GetValue(IsMonthYearProperty);
        }
   
        public static void SetIsMonthYear(DependencyObject dobj, bool value)
        {
            dobj.SetValue(IsMonthYearProperty, value);
        }
   
        private static void OnIsMonthYearChanged(DependencyObject dobj, DependencyPropertyChangedEventArgs e)
        {
            var datePicker = (DatePicker)dobj;
   
            Application.Current.Dispatcher
                .BeginInvoke(DispatcherPriority.Loaded,
                             new Action<DatePicker, DependencyPropertyChangedEventArgs>(SetCalendarEventHandlers),
                             datePicker, e);
        }
   
        private static void SetCalendarEventHandlers(DatePicker datePicker, DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue == e.OldValue)
                return;
   
            if ((bool)e.NewValue)
            {
                datePicker.CalendarOpened += DatePickerOnCalendarOpened;
                datePicker.CalendarClosed += DatePickerOnCalendarClosed;
            }
            else
            {
                datePicker.CalendarOpened -= DatePickerOnCalendarOpened;
                datePicker.CalendarClosed -= DatePickerOnCalendarClosed;
            }
        }
   
        private static void DatePickerOnCalendarOpened(object sender, RoutedEventArgs routedEventArgs)
        {
            var calendar = GetDatePickerCalendar(sender);
            calendar.DisplayMode = CalendarMode.Year;
   
            calendar.DisplayModeChanged += CalendarOnDisplayModeChanged;
        }
   
        private static void DatePickerOnCalendarClosed(object sender, RoutedEventArgs routedEventArgs)
        {
            var datePicker = (DatePicker)sender;
            var calendar = GetDatePickerCalendar(sender);
            datePicker.SelectedDate = calendar.SelectedDate;
   
            calendar.DisplayModeChanged -= CalendarOnDisplayModeChanged;
        }
   
        private static void CalendarOnDisplayModeChanged(object sender, CalendarModeChangedEventArgs e)
        {
            var calendar = (System.Windows.Controls.Calendar)sender;
            if (calendar.DisplayMode != CalendarMode.Month)
                return;
   
            calendar.SelectedDate = GetSelectedCalendarDate(calendar.DisplayDate);
   
            var datePicker = GetCalendarsDatePicker(calendar);
            datePicker.IsDropDownOpen = false;
        }
   
        private static System.Windows.Controls.Calendar GetDatePickerCalendar(object sender)
        {
            var datePicker = (DatePicker)sender;
            var popup = (Popup)datePicker.Template.FindName("PART_Popup", datePicker);
            return ((System.Windows.Controls.Calendar)popup.Child);
        }
   
        private static DatePicker GetCalendarsDatePicker(FrameworkElement child)
        {
            var parent = (FrameworkElement)child.Parent;
            if (parent.Name == "PART_Root")
                return (DatePicker)parent.TemplatedParent;
            return GetCalendarsDatePicker(parent);
        }
   
        private static DateTime? GetSelectedCalendarDate(DateTime? selectedDate)
        {
            if (!selectedDate.HasValue)
                return null;
            return new DateTime(selectedDate.Value.Year, selectedDate.Value.Month, 1);
        }
    }
   
    public class DatePickerDateFormat
    {
        public static readonly DependencyProperty DateFormatProperty =
            DependencyProperty.RegisterAttached("DateFormat", typeof(string), typeof(DatePickerDateFormat),
                                                new PropertyMetadata(OnDateFormatChanged));
   
        public static string GetDateFormat(DependencyObject dobj)
        {
            return (string)dobj.GetValue(DateFormatProperty);
        }
   
        public static void SetDateFormat(DependencyObject dobj, string value)
        {
            dobj.SetValue(DateFormatProperty, value);
        }
   
        private static void OnDateFormatChanged(DependencyObject dobj, DependencyPropertyChangedEventArgs e)
        {
            var datePicker = (DatePicker)dobj;
   
            Application.Current.Dispatcher.BeginInvoke(
                DispatcherPriority.Loaded, new Action<DatePicker>(ApplyDateFormat), datePicker);
        }
        private static void ApplyDateFormat(DatePicker datePicker)
        {
            var binding = new Binding("SelectedDate")
            {
                RelativeSource = new RelativeSource { AncestorType = typeof(DatePicker) },
                Converter = new DatePickerDateTimeConverter(),
                ConverterParameter = new Tuple<DatePicker, string>(datePicker, GetDateFormat(datePicker)),
                StringFormat = GetDateFormat(datePicker) // This is also new but didnt seem to help
            };
   
            var textBox = GetTemplateTextBox(datePicker);
            textBox.SetBinding(TextBox.TextProperty, binding);
   
            textBox.PreviewKeyDown -= TextBoxOnPreviewKeyDown;
            textBox.PreviewKeyDown += TextBoxOnPreviewKeyDown;
   
            var dropDownButton = GetTemplateButton(datePicker);
   
            datePicker.CalendarOpened -= DatePickerOnCalendarOpened;
            datePicker.CalendarOpened += DatePickerOnCalendarOpened;
   
            // Handle Dropdownbutton PreviewMouseUp to prevent issue of flickering textboxes
            dropDownButton.PreviewMouseUp -= DropDownButtonPreviewMouseUp;
            dropDownButton.PreviewMouseUp += DropDownButtonPreviewMouseUp;
        }
   
        private static ButtonBase GetTemplateButton(DatePicker datePicker)
        {
            return (ButtonBase)datePicker.Template.FindName("PART_Button", datePicker);
        }
   
        /// <summary>
        ///     Prevents a bug in the DatePicker, where clicking the Dropdown open button results in Text being set to default formatting regardless of StringFormat or binding overrides
        /// </summary>
        private static void DropDownButtonPreviewMouseUp(object sender, MouseButtonEventArgs e)
        {
            var fe = sender as FrameworkElement;
            if (fe == null) return;
   
            var datePicker = fe.TryFindParent<DatePicker>();
            if (datePicker == null || datePicker.SelectedDate == null) return;
   
            var dropDownButton = GetTemplateButton(datePicker);
   
            // Dropdown button was clicked
            if (e.OriginalSource == dropDownButton && datePicker.IsDropDownOpen == false)
            {
                // Open dropdown
                datePicker.SetCurrentValue(DatePicker.IsDropDownOpenProperty, true);
   
                // Mimic everything else in the standard DatePicker dropdown opening *except* setting textbox value 
                datePicker.SetCurrentValue(DatePicker.DisplayDateProperty, datePicker.SelectedDate.Value);
   
                // Important otherwise calendar does not work
                dropDownButton.ReleaseMouseCapture();
   
                // Prevent datePicker.cs from handling this event 
                e.Handled = true;
            }
        }
   
        private static TextBox GetTemplateTextBox(Control control)
        {
            control.ApplyTemplate();
            return (TextBox)control?.Template?.FindName("PART_TextBox", control);
        }
   
        private static void TextBoxOnPreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key != Key.Return)
                return;
   
            /* DatePicker subscribes to its TextBox's KeyDown event to set its SelectedDate if Key.Return was
             * pressed. When this happens its text will be the result of its internal date parsing until it
             * loses focus or another date is selected. A workaround is to stop the KeyDown event bubbling up
             * and handling setting the DatePicker.SelectedDate. */
   
            e.Handled = true;
   
            var textBox = (TextBox)sender;
            var datePicker = (DatePicker)textBox.TemplatedParent;
            var dateStr = textBox.Text;
            var formatStr = GetDateFormat(datePicker);
            datePicker.SelectedDate = DatePickerDateTimeConverter.StringToDateTime(datePicker, formatStr, dateStr);
        }
   
        private static void DatePickerOnCalendarOpened(object sender, RoutedEventArgs e)
        {
            /* When DatePicker's TextBox is not focused and its Calendar is opened by clicking its calendar button
             * its text will be the result of its internal date parsing until its TextBox is focused and another
             * date is selected. A workaround is to set this string when it is opened. */
   
            var datePicker = (DatePicker)sender;
            var textBox = GetTemplateTextBox(datePicker);
            var formatStr = GetDateFormat(datePicker);
            textBox.Text = DatePickerDateTimeConverter.DateTimeToString(formatStr, datePicker.SelectedDate);
        }
   
        private class DatePickerDateTimeConverter : IValueConverter
        {
            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
            {
                var formatStr = ((Tuple<DatePicker, string>)parameter).Item2;
                var selectedDate = (DateTime?)value;
                return DateTimeToString(formatStr, selectedDate);
            }
   
            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
            {
                var tupleParam = ((Tuple<DatePicker, string>)parameter);
                var dateStr = (string)value;
                return StringToDateTime(tupleParam.Item1, tupleParam.Item2, dateStr);
            }
   
            public static string DateTimeToString(string formatStr, DateTime? selectedDate)
            {
                return selectedDate.HasValue ? selectedDate.Value.ToString(formatStr) : null;
            }
   
            public static DateTime? StringToDateTime(DatePicker datePicker, string formatStr, string dateStr)
            {
                DateTime date;
                var canParse = DateTime.TryParseExact(dateStr, formatStr, CultureInfo.CurrentCulture,
                                                      DateTimeStyles.None, out date);
   
                if (!canParse)
                    canParse = DateTime.TryParse(dateStr, CultureInfo.CurrentCulture, DateTimeStyles.None, out date);
   
                return canParse ? date : datePicker.SelectedDate;
            }
        }
    }
   
    public static class FEExten
    {
        /// <summary>
        /// Finds a parent of a given item on the visual tree.
        /// </summary>
        /// <typeparam name="T">The type of the queried item.</typeparam>
        /// <param name="child">A direct or indirect child of the
        /// queried item.</param>
        /// <returns>The first parent item that matches the submitted
        /// type parameter. If not matching item can be found, a null
        /// reference is being returned.</returns>
        public static T TryFindParent<T>(this DependencyObject child)
            where T : DependencyObject
        {
            //get parent item
            DependencyObject parentObject = GetParentObject(child);
   
            //we've reached the end of the tree
            if (parentObject == null) return null;
   
            //check if the parent matches the type we're looking for
            T parent = parentObject as T;
            if (parent != null)
            {
                return parent;
            }
            else
            {
                //use recursion to proceed with next level
                return TryFindParent<T>(parentObject);
            }
        }
   
        /// <summary>
        /// This method is an alternative to WPF's
        /// <see cref="VisualTreeHelper.GetParent"/> method, which also
        /// supports content elements. Keep in mind that for content element,
        /// this method falls back to the logical tree of the element!
        /// </summary>
        /// <param name="child">The item to be processed.</param>
        /// <returns>The submitted item's parent, if available. Otherwise
        /// null.</returns>
        public static DependencyObject GetParentObject(this DependencyObject child)
        {
            if (child == null) return null;
   
            //handle content elements separately
            ContentElement contentElement = child as ContentElement;
            if (contentElement != null)
            {
                DependencyObject parent = ContentOperations.GetParent(contentElement);
                if (parent != null) return parent;
   
                FrameworkContentElement fce = contentElement as FrameworkContentElement;
                return fce != null ? fce.Parent : null;
            }
   
            //also try searching for parent in framework elements (such as DockPanel, etc)
            FrameworkElement frameworkElement = child as FrameworkElement;
            if (frameworkElement != null)
            {
                DependencyObject parent = frameworkElement.Parent;
                if (parent != null) return parent;
            }
   
            //if it's not a ContentElement/FrameworkElement, rely on VisualTreeHelper
            return VisualTreeHelper.GetParent(child);
        }
    }

3. xaml에서의 사용

   <DatePicker tk:DatePickerCalendar.IsMonthYear="True" tk:DatePickerDateFormat.DateFormat="yyyy-MMM" Text="yyyy-MMM" SelectedDate="{Binding SEL_MONTH}" Grid.Column="1" Margin="0,0,5,0" VerticalAlignment="Center"/>

   앞의 tk는 DatePickerCalendar.cs가 작성된 폴더이다. namespace에 추가하면된다.

선택한 년/월의 Binding은 CommandParameter를 사용한다...

4. 결과

5. 참조

• https://stackoverflow.com/questions/1798513/wpf-toolkit-datepicker-month-year-only

MVVM 패턴으로 작성된 프로젝트에서 예를 들어 하나의 버튼을 ViewModel에 눌렀을 때 CommandParameter를 전달하는 방법은??

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. 위와 같이 컨트롤을 배치했다고 합시다. TextBox A와 TextBox B에 작성한 내용을 Click Button을 눌러 TextBox C와 TextBox D에 Binding 합니다.

    <Grid>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="0,0,0,10">
                <Label Content="A :" />
                <TextBox x:Name="TextBoxA" Width="100" Text="{Binding TextBoxA}" Margin="0,0,10,0"/>
                <Label Content="B :" />
                <TextBox x:Name="TextBoxB" Width="100" Text="{Binding TextBoxB}"/>
            </StackPanel>

            <Button Content="Click" Margin="0,0,0,10" Cursor="Hand" Command="{Binding bindingButtonCommand}">
                <Button.CommandParameter>
                    <MultiBinding Converter="{StaticResource MultiCommandParameterCv}">
                        <Binding ElementName="TextBoxA" Path="Text" />
                        <Binding ElementName="TextBoxB" Path="Text" />
                    </MultiBinding>
                </Button.CommandParameter>
            </Button>

            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
                <Label Content="C :" />
                <TextBox Width="100" Text="{Binding TextBoxC}" Margin="0,0,10,0"/>
                <Label Content="D :" />
                <TextBox Width="100" Text="{Binding TextBoxD}"/>
            </StackPanel>
        </StackPanel>
    </Grid>

2. Converter를 작성합니다. Converter는 IMultiValueConverter를 상속 받습니다.

    public class MultiCommandParameterConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            return values.Clone();
        }

        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }

4. Converter를 사용할 수 있도록 xaml의 namespace와 Resource를 추가합니다.

5. ViewModel에 Command와 Binding할 변수를 선언합니다.

        public ICommand bindingButtonCommand { get; set; }

        private string _textBoxA;
        private string _textBoxB;
        private string _textBoxC;
        private string _textBoxD;

        public string TextBoxA
        {
            get { return _textBoxA; }
            set 
            {
                _textBoxA = value;
                OnPropertyChanged(nameof(TextBoxA));
            }
        }

        public string TextBoxB
        {
            get { return _textBoxB; }
            set
            {
                _textBoxB = value;
                OnPropertyChanged(nameof(TextBoxB));
            }
        }

        public string TextBoxC
        {
            get { return _textBoxC; }
            set
            {
                _textBoxC = value;
                OnPropertyChanged(nameof(TextBoxC));
            }
        }

        public string TextBoxD
        {
            get { return _textBoxD; }
            set
            {
                _textBoxD = value;
                OnPropertyChanged(nameof(TextBoxD));
            }
        }

        public Page5ViewModel() 
        {
            bindingButtonCommand = new RelayCommand<object>(bindingButton);
        }

        private void bindingButton(object parameters)
        {
            var parameter = (object[])parameters;

            TextBoxC = parameter[0] as string;
            TextBoxD = parameter[1] as string;
        }

Button을 눌러 Command가 실행되면 CommandParameter를 통해 넘겨받은 값이 object형의 parameters에 들어있습니다. 배열로 Casting하여 var parameter에 담고 TextBoxC와 TextBoxD에 각각 string으로 Casting한 값을 담습니다.

4. 결과

5. 참조

• https://gapal.tistory.com/28

6. 생각해볼점

사실 텍스트박스에 작성한 내용을 굳이 버튼을 클릭해서 Multi Parameter로 넘기지 않아도 다른 텍스트박스에 바인딩되게 할 수 있지만... 저는 주로 검색 기능 구현할 때 많이 쓰는 것 같아요.

이전(이 글)에 싱글톤 패턴으로 페이지의 인스턴스를 호출하여 x:Name을 통해 CheckBox의 내용을 가져오는 방식을 사용했었다. 아무리 싱글톤으로 만든 인스턴스라지만 자주 호출하는 것이 영 꺼림칙하여 Xceed Wpf ToolKit을 사용하지 않고 Converter를 작성하여 CheckBox에서 선택한 항목을 List로 만드는 방법으로 변경해보았다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. ViewModel에는 화면에서 선택한 CheckBox를 받을 List가 필요하다.

        //CheckBox
        public List<string> CheckedList { get; set; }

2. Converter를 작성한다

    public class CheckBoxToListConverter : IValueConverter
    {
        List<string> bound = new List<string>();

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (bound.Contains(parameter.ToString()))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            bool isChecked = (bool)value;

            if (isChecked)
            {
                bound.Add(parameter.ToString());
            }
            else
            {
                bound.Remove(parameter.ToString());
            }

            return bound;
        }
    }

3. 화면의 CheckBox에 List와 Converter를 바인딩한다.

<CheckBox Content="A" IsChecked="{Binding CheckedList, Converter={StaticResource CheckBoxToListCV}, ConverterParameter='A'}"/>
<CheckBox Content="B" IsChecked="{Binding CheckedList, Converter={StaticResource CheckBoxToListCV}, ConverterParameter='B'}"/>
<CheckBox Content="C" IsChecked="{Binding CheckedList, Converter={StaticResource CheckBoxToListCV}, ConverterParameter='C'}"/>
<CheckBox Content="D" IsChecked="{Binding CheckedList, Converter={StaticResource CheckBoxToListCV}, ConverterParameter='D'}"/>

4. CheckBox 선택한 항목을 콘솔에서 출력하여 확인하기

for (int i = 0; i < CheckedList.Count; i++) 
{
    Console.WriteLine(CheckedList[i]);
}

4. 결과

이전 코드를 활용하여 버튼을 누르면 콘솔에 출력되도록 작성해보았다.

5. 참조

• https://stackoverflow.com/questions/60633809/binding-wpf-checkbox-ischecked-to-a-list

6. 생각해볼점

Converter와 CommandParameter 등 이전보다 WPF에 대해 더 많이 알게 된 것 같은 기분이 드는 동시에...난 아직 스택오버플로우가 없으면 Converter 작성하기는 너무 어려운 것 같다. 😂

https://velog.io/@yu_oolong/Spring-JSTL로-화면에-D-day-보여주기 이 글에서 언급한 토이 프로젝트에서 캘린더를 구현하는데 캘린더에 공휴일을 표시해줄 것인지 말 것인지 토글로 on/off할 수 있도록 한다.

2. 개발환경

• Java 1.8
• SpringFramework

3. 내용

1. 공공 데이터 포털에서 한국천문연구원 특일 정보 오픈 API 활용 신청하기 https://www.data.go.kr/data/15012690/openapi.do

2. Service - RequestAPI.java https://minaminaworld.tistory.com/211 코드 사용

public class RequestAPI {

    private static String secretKey = "발급받은 서비스키";

    public static Map<String, Object> holidayInfoAPI(String year, String month) throws IOException {
        StringBuilder urlBuilder = new StringBuilder("http://apis.data.go.kr/B090041/openapi/service/SpcdeInfoService/getHoliDeInfo"); /*URL*/
        urlBuilder.append("?" + URLEncoder.encode("serviceKey", "UTF-8") + "=" + secretKey); /*Service Key*/
        urlBuilder.append("&" + URLEncoder.encode("pageNo", "UTF-8") + "=" + URLEncoder.encode("1", "UTF-8")); /*페이지번호*/
        urlBuilder.append("&" + URLEncoder.encode("numOfRows", "UTF-8") + "=" + URLEncoder.encode("10", "UTF-8")); /*한 페이지 결과 수*/
        urlBuilder.append("&" + URLEncoder.encode("solYear", "UTF-8") + "=" + URLEncoder.encode(year, "UTF-8")); /*연 */
        urlBuilder.append("&" + URLEncoder.encode("solMonth", "UTF-8") + "=" + URLEncoder.encode(month.length() == 1 ? "0" + month : month, "UTF-8")); /*월*/
        urlBuilder.append("&" + URLEncoder.encode("_type", "UTF-8") + "=" + URLEncoder.encode("json", "UTF-8")); /* json으로 요청 */

        URL url = new URL(urlBuilder.toString());
        System.out.println("요청URL = " + urlBuilder);

        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Content-type", "application/json");
        System.out.println("Response code: " + conn.getResponseCode());

        BufferedReader rd;
        if (conn.getResponseCode() >= 200 && conn.getResponseCode() <= 300) {
            rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        } else {
            rd = new BufferedReader(new InputStreamReader(conn.getErrorStream()));
        }
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = rd.readLine()) != null) {
            sb.append(line);
        }
        rd.close();
        conn.disconnect();
        // System.out.println(sb.toString());

        return string2Map(sb.toString());
    }

    /**
     * Json String을 Hashmap으로 반환
     *
     * @param json
     * @return
     */
    public static Map<String, Object> string2Map(String json) {
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> map = null;

        try {
            map = mapper.readValue(json, Map.class);
            System.out.println(map);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }
}

3. Controller https://minaminaworld.tistory.com/211 코드 응용

    //공휴일 Ajax
    @PostMapping("/GetHoliday")
    @ResponseBody
    public ResponseEntity<ArrayList<HashMap<String, Object>>> holidayInfoApi(String year, String month) {
   
        System.out.println("year = " + year);
        System.out.println("month = " + month);
   
        ArrayList<HashMap<String, Object>> responseHolidayArr = new ArrayList<HashMap<String, Object>>();
   
        RequestAPI requestAPI = new RequestAPI();
   
        try {
            Map<String, Object> holidayMap = requestAPI.holidayInfoAPI(year, month);
            Map<String, Object> response = (Map<String, Object>) holidayMap.get("response");
            Map<String, Object> body = (Map<String, Object>) response.get("body");
   
            int totalCount = (int) body.get("totalCount");
   
            if(totalCount <= 0) {
                System.out.println("공휴일 없음");
                System.out.println("body = " + body);
            }
            if(totalCount == 1) {
                HashMap<String, Object> items = (HashMap<String, Object>) body.get("items");
                HashMap<String, Object> item = (HashMap<String, Object>) items.get("item");
                responseHolidayArr.add(item);
                System.out.println("item = " + item);
            }
            if(totalCount > 1) {
                HashMap<String, Object> items = (HashMap<String, Object>) body.get("items");
                ArrayList<HashMap<String, Object>> item = (ArrayList<HashMap<String,Object>>) items.get("item");
                for(HashMap<String, Object> itemMap : item) {
                    System.out.println("itemMap = " + itemMap);
                    responseHolidayArr.add(itemMap);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new ResponseEntity<>(responseHolidayArr, HttpStatus.OK);
    }

4. JSP

   <span>공휴일 자동 표시</span>
   <input data-toggle="toggle" id="publicAutoN" type="checkbox">

5. JavaScript

    $(document).ready(function() {
          //공휴일 자동 표시
        $(document).on("change", "#publicAutoY", function(){
            console.log("Y->N");
            $("#publicAutoY").removeAttr("checked");
            $("#publicAutoY").attr("id", "publicAutoN");
   
            var year = $("#year").text();
            var month = $("#month").text();
   
            //Ajax로 전송
            $.ajax({
                url : './GetHoliday',
                data : {
                    year : year,
                    month : month
                },
                type : 'POST',
                dataType : 'json',
                success : function(result) {
                    if(result != "") {
                        //div id가 dateiDay인 것들을 전부 조회하여 dateiDay의 .text()값과 조회해온 공휴일 날짜를 비교하여 일치하면 dateContent에 .append()한다.
                        for(var i = 1; i <= 31; i++) {
                            for(var j = 0; j < result.length; j++) {
                                var dateName = result[j].dateName;
                                var dateId;
                                //ex)공휴일이 20231003이면 끝의 한 자리만 잘라내고 20231225면 끝의 두 자리면 잘라낸다.
                                if(((result[j].locdate).toString()).slice(-2).match("0")) {
                                    dateId = "date" + ((result[j].locdate).toString()).slice(-1);
                                }
                                else {
                                    dateId = "date" + ((result[j].locdate).toString()).slice(-2);
                                }
                                var dateContentId = dateId + "Content";
   
                                var date = ((result[j].locdate).toString()).slice(-1);
   
                                if ($("#date" + i + "Day").text() == ((result[j].locdate).toString()).slice(-1) || $("#date" + i + "Day").text() == ((result[j].locdate).toString()).slice(-2)) {
                                    $("#" + dateContentId).empty();
                                }
                            }
                        }
                    }
                }
            }); //End Ajax
        });
   
        $(document).on("change", "#publicAutoN", function(){
            console.log("N->Y");
            $("#publicAutoN").attr("checked", "checked");
            $("#publicAutoN").attr("id", "publicAutoY");
   
            var year = $("#year").text();
            var month = $("#month").text();
   
            //Ajax로 전송
            $.ajax({
                url : './GetHoliday',
                data : {
                    year : year,
                    month : month
                },
                type : 'POST',
                dataType : 'json',
                success : function(result) {
                    if(result != "") {
                        //div id가 dateiDay인 것들을 전부 조회하여 dateiDay의 .text()값과 조회해온 공휴일 날짜를 비교하여 일치하면 dateContent에 .append()한다.
                        for(var i = 1; i <= 31; i++) {
                            for(var j = 0; j < result.length; j++) {
                                var dateName = result[j].dateName;
                                var dateId;
                                //ex)공휴일이 20231003이면 끝의 한 자리만 잘라내고 20231225면 끝의 두 자리면 잘라낸다.
                                if(((result[j].locdate).toString()).slice(-2).match("0")) {
                                    dateId = "date" + ((result[j].locdate).toString()).slice(-1);
                                }
                                else {
                                    dateId = "date" + ((result[j].locdate).toString()).slice(-2);
                                }
                                var dateContentId = dateId + "Content";
   
                                var date = ((result[j].locdate).toString()).slice(-1);
   
                                if ($("#date" + i + "Day").text() == ((result[j].locdate).toString()).slice(-1) || $("#date" + i + "Day").text() == ((result[j].locdate).toString()).slice(-2)) {
                                    $("#" + dateId).css("color", "#ff0000");
                                    $("#" + dateContentId).append("<br>");
                                    $("#" + dateContentId).append("<a></a>&nbsp");
                                    $("#" + dateContentId).append(dateName).css("color", "#ff0000");
                                }
                            }
                        }
                    }
                }
            }); //End Ajax
        });
    }

4. 결과

5. 참조

• https://www.data.go.kr/index.do
• https://minaminaworld.tistory.com/211

DataGrid의 ItemsSource에 컬렉션이 이미 바인딩 되어있을 때, 컬렉션에 포함된 내용 외에 DataGrid의 컬럼에 이벤트를 걸기 위한 Command를 ViewModel에서 찾아 호출하는 방법 찾기

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. 위와 같은 화면이 있다고 했을 때 관리자Y/N 컬럼에 CheckBox를 보이게 하고싶다. DataGridCheckBoxColumn을 사용하면 되지만 CheckBox가 Checked될 때 이벤트를 걸기 위해 DataGridTemplateColumn으로 CheckBox를 만들어주고 Behavior 를 작성하여 Command를 Binding 하려고 하는데 목록에 만들어준 Command가 보이지 않는다.

이유는 아마 DataGrid의 ItemsSource로 ObservableCollection을 바인딩 해둬서 그런 것 같다. 바인딩한 컬렉션의 내용물 외에는 바인딩 목록에 나오지 않는 것이다.

2. 좀 길지만 ViewModel에서 작성해둔 Command를 Binding 하는 방법으로 RelativeSource 속성이 있다. RelativeSource는 바인딩 할 객체를 찾아준다. Page4ViewModel에서 찾겠다고 하고 Path를 작성하려고 하면 작성해둔 Command를 목록에서 찾을 수 있다.

            <DataGrid x:Name="ExcelData" ItemsSource="{Binding excelContentsList}" CanUserAddRows="False">
                <DataGrid.Columns>
                    <DataGridTextColumn Header="이름" Binding="{Binding NAME}"/>
                    <DataGridTextColumn Header="품목"  Binding="{Binding MANUFACTURER}"/>
                    <DataGridTextColumn Header="제조사" Binding="{Binding NUMBER}"/>
                    <DataGridTextColumn Header="날짜" Binding="{Binding INCOMING_DATE}"/>
                    <DataGridTemplateColumn Header="관리자Y/N">
                        <DataGridTemplateColumn.CellTemplate>
                            <DataTemplate>
                                <CheckBox>
                                    <i:Interaction.Triggers>
                                        <i:EventTrigger EventName="Checked">
                                            <i:InvokeCommandAction Command="{Binding }"/>
                                        </i:EventTrigger>
                                    </i:Interaction.Triggers>
                                </CheckBox>
                            </DataTemplate>
                        </DataGridTemplateColumn.CellTemplate>
                    </DataGridTemplateColumn>
                </DataGrid.Columns>
            </DataGrid>

4. 참조

• https://stackoverflow.com/questions/10931856/mvvm-wpf-bindings-with-relativesource

WPF DataGrid의 선 색, 굵기와 행을 선택했을 때 글자 색, 배경 색 변경 방법에 대하여...

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

1. 화면에 배치한 DataGrid가 Grid 안에 있는 DataGrid여야 한다.

2. DataGrid Style을 지정하는 태그들은 <Grid.Resources> 안에 작성한다.

3. 가로 선은 Red, 세로 선은 Blue로 지정한다.

4. Trigger로 행이 선택됐을 때(IsSelected가 True일때), 선택한 행의 Background 색은 Beige, Foreground 색은 Brown이 되도록 한다.

    <Grid Grid.Row="2" Margin="10,0,10,0">
            <Grid.Resources>
                <Style TargetType="DataGrid">
                    <Setter Property="HorizontalGridLinesBrush" Value="red"/>
                    <Setter Property="VerticalGridLinesBrush" Value="Blue" />
                </Style>
                <Style TargetType="DataGridColumnHeader">
                    <Setter Property="HorizontalContentAlignment" Value="Center"/>
                </Style>
                <Style TargetType="DataGridCell">
                    <Style.Triggers>
                        <Trigger Property="IsSelected" Value="True">
                            <Setter Property="Background" Value="Beige"/>
                            <Setter Property="Foreground" Value="Brown"/>
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </Grid.Resources>
   
            <DataGrid x:Name="ExcelData" ItemsSource="{Binding 
                <DataGrid.Columns>
                    <DataGridTextColumn Header="이름" Binding="{Binding NAME}"/>
                    <DataGridTextColumn Header="품목"  Binding="{Binding MANUFACTURER}"/>
                    <DataGridTextColumn Header="제조사" Binding="{Binding NUMBER}"/>
                    <DataGridTextColumn Header="날짜" Binding="{Binding INCOMING_DATE}"/>
                    <DataGridTextColumn Header="관리자" Binding="{Binding MANAGER}"/>
                </DataGrid.Columns>
            </DataGrid>
        </Grid>

   DataGridColumnHeader의 경우 가운데 정렬만 Style로 지정해놓았는데 다른 속성들과 마찬가지로 배경 색, 글자 색, 글자 크기 등의 Style 변경이 가능하다.

4. 결과

셀의 가로 선은 빨강, 세로 선은 파랑이고 선택한 행의 셀 배경 색이 베이지, 글자 색은 브라운이 되는 트리거가 작동된 것을 확인할 수 있다. 이건 Style이 적용되지 않은 기본 DataGrid

5. 참조

• 마이크로소프트 공식 문서

Check된 CheckBox의 Content를 저장하여 TextBlock에 보여준다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)
• 이 링크에 해당하는 ToolKit 설치를 전제로 한다.
• https://velog.io/@yu_oolong/C-WPF-Button을-눌러-Frame에-Page-띄우기-1 에서 작성한 프로젝트에서 추가한 내용이다.

3. 내용

1. GroupBox 내에 Grid가 있고 그 Grid안에 CheckBox를 세 개 배치했다. 그리고 아래에 Button과 보이진 않지만 TextBlock이 있다.

xaml 코드)

    <Grid>
        <Grid HorizontalAlignment="Center" VerticalAlignment="Center" >
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
            </Grid.RowDefinitions>

            <GroupBox Grid.Row="0" x:Name="CheckBoxGroup" Header="그룹 박스">
                <Grid HorizontalAlignment="Center">
                    <Grid.RowDefinitions>
                        <RowDefinition />
                        <RowDefinition />
                        <RowDefinition />
                    </Grid.RowDefinitions>

                    <CheckBox x:Name="choose1" Grid.Row="0" Content="선택1"/>
                    <CheckBox x:Name="choose2" Grid.Row="1" Content="선택2"/>
                    <CheckBox x:Name="choose3" Grid.Row="2" Content="선택3"/>
                </Grid>
            </GroupBox>
            <Button x:Name="chooseBtn" Grid.Row="1" Content="선택"/>
            <TextBlock x:Name="Content" Grid.Row="2" Width="200"/>
        </Grid>

    </Grid>

GroupBox와 CheckBox 컨트롤, 선택한 CheckBox의 Content를 보여줄 TextBlock의 x:Name을 지정해주어야 한다. ViewModel에서 지정한 x:Name을 통해 Content를 가져올 것이기 때문이다.

2. View의 코드 비하인드에서 View를 싱글톤으로 만든다.

    public partial class Page6 : Page
    {
        private static Page6 _Instance = null;
   
        public static Page6 GetInstance()
        {
            if (_Instance == null || !_Instance.IsLoaded)
            {
                _Instance = new Page6();
            }
   
            return _Instance;
        }
   
        public Page6()
        {
            InitializeComponent();
   
            _Instance = this;
        }
    }

3. ViewModel에서 선택 버튼을 누르면 TextBlock에 내용을 보여주는 Command를 작성한다.

4. chooseCheckBox에 로직을 작성하기 위해 TextBlock에 바인딩 할 데이터를 선언한다.

5. 싱글톤으로 만든 View의 인스턴스를 호출하고 x:Name으로 지정한 컨트롤에 접근하여 내용을 가져오는데, .FindLogicalChildren<>() 메소드는 Xceed WPF Toolkit을 설치해야 사용할 수 있다. CheckBoxGroup이라는 x:Name을 가진 GroupBox 트리 내의 CheckBox 컨트롤들을 CheckBox 타입의 checkBox에 담고 if문에서 IsChecked가 True인 CheckBox의 Content를 string 변수 cb에 담은 후 cbStr에 이어붙인다.

ViewModel 코드)

    internal class Page6ViewModel : BaseViewModel
    {
        public ICommand chooseCheckBoxCommand { get; set; }

        public List<string> checkBoxList = new List<string>();

        private string _checkBoxText { get; set; }

        public string CheckBoxText
        {
            get { return _checkBoxText; }
            set 
            { 
                _checkBoxText = value; 
                OnPropertyChanged(nameof(CheckBoxText)); 
            }
        }

        public Page6ViewModel() 
        {
            chooseCheckBoxCommand = new RelayCommand(chooseCheckBox);
        }

        private void chooseCheckBox()
        {
            Page6 page6 = Page6.GetInstance();

            string cb = "";
            string cbStr = "";

            foreach(CheckBox checkBox in page6.CheckBoxGroup.FindLogicalChildren<CheckBox>())
            {
                if(checkBox.IsChecked == true)
                {
                    cb = checkBox.Content.ToString();
                    cbStr += cb;
                }
            }

            CheckBoxText = cbStr;
        }

    }

4. 결과

문자열을 이어붙여 하나의 string 변수에 담는게 아니라 나눠서 저장하고 싶다면 List를 사용하면 된다.

5. 생각해보기

사실 다른 프로젝트를 하면서 먼저 Xceed Wpf ToolKit을 설치해 뒀었기 때문에 아무 생각없이 FindLogicalChildren...메소드를 사용했었다. 그러다 기록을 위해 연습용 솔루션에서 똑같이 작성하려고 하니 자동완성으로 저 메소드가 생기질 않아 난감해했었다. 찾아보니 그제야 Xceed Wpf ToolKit에서 제공하는 메소드였던 것임을 알게 되었다... ToolKit을 설치하지 않고도 선택한 CheckBox의 Content의 값을 가져오는 방법이 분명 있을텐데 왜 못찾았을까?? 구글링도...스스로 생각해보는 힘도 둘 다 모자란 것 같다...

버튼을 눌러 .txt나 .xlsx같은 확장자를 가진 파일을 연다.

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

3-1. 프로젝트 생성 및 폴더 구조

https://velog.io/@yu_oolong/C-WPF-MVVM-패턴으로-프로젝트-시작하기 와 같이 프로젝트를 생성한다. 폴더 구조는 다음과 같다.

3-2. 컨트롤 배치

버튼을 눌러서 외부 파일을 실행하기 위해 화면에 Button 컨트롤을 배치한다.

<Page x:Class="PracticeProject2.Views.Page5"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      xmlns:local="clr-namespace:PracticeProject2.Views"
      mc:Ignorable="d" 
      d:DesignHeight="450" d:DesignWidth="800"
      Title="Page5"
      Background="White">

    <Grid>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <Button Content="Open File" Width="100" Height="50" Cursor="Hand"/>
        </StackPanel>
    </Grid>
</Page>

3-3. RelayCommand, BaseViewModel 작성

1. Commands 폴더에 RelayCommand.cs 생성하여 작성한다.

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using System.Windows.Input;
   

namespace PackagingSystem.Commands { public class RelayCommand : ICommand { private readonly Action _execute; private readonly Func _canExecute;

    public RelayCommand(Action execute, Func<bool> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    public bool CanExecute(object parameter) => _canExecute == null || _canExecute();

    public void Execute(object parameter) => _execute();
}

}

2. ViewModels 폴더에 INotifyPropertyChanged를 상속받는 BaseViewModel.cs을 생성하여 작성한다.
```cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace PracticeProject2.ViewModels
{
    internal class BaseViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        protected bool SetProperty<T>(ref T backingField, T value, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(backingField, value)) return false;
            backingField = value;
            OnPropertyChanged(propertyName);
            return true;
        }
    }
}

3-4. BaseViewModel을 상속 받는 ViewModel 작성

1. View인 page5.xaml의 ViewModel인 Page5ViewModel.cs를 생성한다.
2. BaseViewModel을 상속 받고 Command를 작성한다.
3. Process.Start 메서드로 경로에 해당하는 파일을 실행하는 Command이다.

   using PracticeProject2.Commands;
   using System;
   using System.Collections.Generic;
   using System.Diagnostics;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using System.Windows.Input;
   

namespace PracticeProject2.ViewModels { internal class Page5ViewModel : BaseViewModel { public ICommand openFileCommand { get; set; }

    public Page5ViewModel() 
    {
        openFileCommand = new RelayCommand(openFile);
    }

    private void openFile()
    {
        string directory = @"D:\\Edu\\";
        string filename = "memo.txt";
        string filepath = directory + filename;

        Process.Start(filepath);
    }

}

}

### 3-5. View의 Button에 Command 바인딩하기
1. ViewModels 네임스페이스 명시
2. DataContext 연결하기
3. Button 컨트롤에 Command Binding하기

```xaml
<Page x:Class="PracticeProject2.Views.Page5"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      xmlns:vm="clr-namespace:PracticeProject2.ViewModels"
      xmlns:local="clr-namespace:PracticeProject2.Views"
      mc:Ignorable="d" 
      d:DesignHeight="450" d:DesignWidth="800"
      Title="Page5"
      Background="White">

    <Page.DataContext>
        <vm:Page5ViewModel />
    </Page.DataContext>

    <Grid>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <Button Content="Open File" Width="100" Height="50" Cursor="Hand" Command="{Binding openFileCommand}"/>
        </StackPanel>
    </Grid>
</Page>

4. 결과

실행 후 버튼을 클릭하면 경로로 지정한 파일인 memo.txt 메모장 파일이 실행됐다. .xlsx 파일을 경로로 지정하면 엑셀이 실행된다.

5. 참조

Process.Start 메서드

• https://learn.microsoft.com/ko-kr/dotnet/api/system.diagnostics.process.start?view=net-7.0

파일 탐색기에서 Excel 파일을 불러와 그 내용을 DataGrid에 보여주는 방법... 사실 구글링했을 때 방법이 안나오는건 아닌데 거의 코드 비하인드에 한 방식이기 때문에 MVVM 패턴으로 작성해봤다...근데 코드 비하인드에서의 작성이 아예 없지는 않아서 MVVM 패턴에는 위배되는 것 같다.😂

2. 개발환경

• VisualStudio 2022 / WPF 애플리케이션(.NET Framework 4.7.2)

3. 내용

3-1. 할 일 정하기

https://velog.io/@yu_oolong/C-WPF-Behavior-InvokeCommandAction 와 같은 솔루션에서 진행한다. id, pw를 manager로 입력하면 Menu46까지 보여주고 각 메뉴들은 Page46을 보여준다. 그 중 Page4에서 다음의 내용을 수행한다.

• 1번에서 파일찾기 버튼을 눌러 파일탐색기에서 파일의 이름을 찾고
• 2번에서 찾은 파일을 열어 DataGrid에 보여준다.

3-2. xaml 컨트롤 배치하기

참고로 UI는 이 분 화면을 보고 비슷하게 만들었다.

<Page x:Class="PracticeProject2.Views.Page4"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      xmlns:local="clr-namespace:PracticeProject2.Views"
      mc:Ignorable="d" 
      d:DesignHeight="450" d:DesignWidth="800"
      Title="Page4"
      Background="White">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="100*"/>
            <RowDefinition Height="270*"/>
            <RowDefinition Height="80*"/>
        </Grid.RowDefinitions>

        <Grid Grid.Row="0" Margin="10,0,10,0">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
                <Label Content="파일 이름" />
                <TextBox x:Name="fileUrlTextBox" Width="450" Margin="10,0,10,0" />
                <Button Content="파일찾기"/>
            </StackPanel>
        </Grid>

        <Grid Grid.Row="1" Margin="10,0,10,0">
            <DataGrid x:Name="ExcelData">
                <DataGrid.Resources>
                    <Style TargetType="DataGridColumnHeader">
                        <Setter Property="HorizontalContentAlignment" Value="Center"/>
                    </Style>
                </DataGrid.Resources>
            </DataGrid>
        </Grid>

        <Grid Grid.Row="2" Margin="10,10,10,10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="200*"/>
                <ColumnDefinition Width="580*"/>
            </Grid.ColumnDefinitions>

            <Grid Grid.Column="0">
                <Button Content="들여오기" Width="100" Height="40" HorizontalAlignment="Left" />
            </Grid>

            <Grid Grid.Column="1" HorizontalAlignment="Right">
                <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
                    <Label Content="Go to" />
                    <TextBox Width="30"/>
                    <Label Content="Page" />
                    <Button Content="Go" Margin="0,0,5,0"/>
                    <Button Content="Last Page" Margin="0,0,5,0"/>
                    <Button Content="Next Page" />
                    <Label Content="[total" />
                    <Label Content="1" />
                    <Label Content="page]" />
                    <Label Content="[current" />
                    <Label Content="1" />
                    <Label Content="page]" />
                </StackPanel>
            </Grid>
        </Grid>

    </Grid>
</Page>

3-2. 엑셀 파일만 찾을 수 있는 파일 탐색기

1. ViewModel 폴더에 Page4ViewModel.cs를 생성한다.

• RelayCommand, BaseViewModel 작성은 내용 참고

파일 찾기 버튼을 누르면 파일 탐색기가 열려야 한다. 파일 탐색기는 OpenFileDialog 클래스로 구현되는데 FileDialog.Filter 속성을 사용하여 확장자가 *.xls, *.xlsx인 엑셀 파일만 고를 수 있도록한다.

(Page4ViewModel.cs)

namespace PracticeProject2.ViewModels
{
    internal class Page4ViewModel : BaseViewModel
    {
        public ICommand SuchFileCommand { get; set; }

        string _fileUrl;

        public string FileUrl
        {
            get { return _fileUrl; }
            set
            {
                _fileUrl = value;
                OnPropertyChanged(nameof(FileUrl));
            }
        }

        public Page4ViewModel()
        {
            SuchFileCommand = new RelayCommand(SuchFile);
        }

        private void SuchFile()
        {
            OpenFileDialog dialog = new OpenFileDialog();
            dialog.Filter = "문서 파일 (*.xls,*xlsx)|*.xls;*.xlsx";
            if (dialog.ShowDialog() == true)
            {
                FileUrl = dialog.FileName;
            }
        }

    }
}

2. Page4.xaml로 돌아와서 Button과 TextBox에 Binding하기

        <Grid Grid.Row="0" Margin="10,0,10,0">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
                <Label Content="파일 이름" />
                <TextBox x:Name="fileUrlTextBox" Width="450" Margin="10,0,10,0" Text="{Binding FileUrl}"/>
                <Button Content="파일찾기" Command="{Binding SuchFileCommand}"/>
            </StackPanel>
        </Grid>

   실행해보면 파일 찾기 버튼을 눌러 파일 탐색기를 띄웠을 때 확장자가 *xls, *xlsx인 파일만 보이고, 파일을 고르면 해당 파일의 이름이 TextBox에 보여진다.

3-3. Excel import to DataGrid

다음은 들여오기 버튼을 눌러 파일 탐색기에서 고른 엑셀 파일의 내용을 DataGrid에 보여주어야 한다. Command를 작성하기 전에 솔루션용 NuGet 패키지 관리자에서 Microsoft.Office.Interop.Excel을 다운로드 받는다. 다운로드 후 추가로 참조 관리자-Com에서 Microsoft Office 16.0 Object Library를 체크>확인한다.

이후 Page4ViewModel.cs 에서 using문을 선언한다. using Excel = Microsoft.Office.Interop.Excel

SuchFile() 메소드에서 파일 탐색기를 열어 가져온 파일의 이름을 FileUrl에 초기화했다. ImportFile() 메소드는 DataTable을 생성하여 SuchFile() 메소드에서 초기화한 FileUrl의 엑셀 파일의 내용으로부터 데이터를 저장하고, Page4에 배치된 x:Name이 ExcelData인 DataGrid에 보여준다.

불러올 엑셀 파일의 내용은 이렇다.

(Page4ViewModel.cs)

using Microsoft.Win32;
using PracticeProject2.Commands;
using PracticeProject2.Views;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using System.Windows;
using Excel = Microsoft.Office.Interop.Excel;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Data;
using System.Diagnostics.Eventing.Reader;

namespace PracticeProject2.ViewModels
{
    internal class Page4ViewModel : BaseViewModel
    {
        public ICommand SuchFileCommand { get; set; }
        public ICommand ImportFileCommand { get; set; }

        string _fileUrl;

        public string FileUrl
        {
            get { return _fileUrl; }
            set
            {
                _fileUrl = value;
                OnPropertyChanged(nameof(FileUrl));
            }
        }

        public Page4ViewModel()
        {
            SuchFileCommand = new RelayCommand(SuchFile);
            ImportFileCommand = new RelayCommand(ImportFile);
        }

        private void SuchFile()
        {
            OpenFileDialog dialog = new OpenFileDialog();
            dialog.Filter = "문서 파일 (*.xls,*xlsx)|*.xls;*.xlsx";
            if (dialog.ShowDialog() == true)
            {
                FileUrl = dialog.FileName;
            }
        }

        private void ImportFile()
        {
            Page4 page4 = Page4.GetInstance();

            DataTable dt = new DataTable(); //엑셀 데이터를 위한 컨테이너
            DataRow dr;

            int row = 0;
            int column = 0;

            Excel.Application excelApp = null;
            Excel.Workbook workbook = null;
            Excel.Worksheet worksheet = null;

            try
            {
                excelApp = new Excel.Application();                             //엑셀 어플리케이션 생성
                workbook = excelApp.Workbooks.Open(FileUrl);                    //워크북 열기
                worksheet = workbook.Worksheets.get_Item(1) as Excel.Worksheet; //엑셀 첫 번째 워크시트 가져오기

                Excel.Range range = worksheet.UsedRange;                        //사용중인 셀 범위 가져오기

                //첫 행을 제목으로
                for (column = 1; column <= range.Columns.Count; column++)
                {
                    //header = (range.Cells[1, column] as Excel.Range).Value2.ToString();
                    string str = (string)(range.Cells[1, column] as Excel.Range).Value2;
                    dt.Columns.Add(str, typeof(string));
                }

                //내용 데이터 가져오기
                int rowCounter;
                for (row = 2; row <= range.Rows.Count; row++)
                {
                    dr = dt.NewRow();
                    rowCounter = 0;
                    for (column = 1; column <= range.Columns.Count; column++)
                    {
                        if (range.Cells[row, column] != null && range.Cells[row, column].Value2 != null)
                        {
                            dr[rowCounter] = range.Cells[row, column].Value2.ToString();
                        }
                        else
                        {
                            dr[row] = "";
                        }
                        rowCounter++;
                    }
                    dt.Rows.Add(dr);
                }

                page4.ExcelData.ItemsSource = dt.DefaultView;

                workbook.Close();
                excelApp.Quit();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return;
            }

        }
    }
}

이때 Page4의 GetInstance() 메소드는 Page4.xaml.cs에서 작성해주어야 한다. GetInstance는 싱글톤 패턴으로 작성한 Page4의 객체이다.

(+ 2023.09.26 날짜 형식 추가) 네 번째 컬럼이 '날짜'여서 if(column=4) 일때... 셀의 내용(string)->double로 형 변환하여 날짜 형식으로 행에 추가한다.

                //내용 데이터 가져오기
                int rowCounter; //This variable is used for row index number
                for (row = 2; row <= range.Rows.Count; row++)
                {
                    dr = dt.NewRow(); //assign new row to DataTable
                    rowCounter = 0;
                    for (column = 1; column <= range.Columns.Count; column++) //Loop for available column of excel data
                    {
                        //check if cell is empty
                        if (range.Cells[row, column] != null && range.Cells[row, column].Value2 != null)
                        {
                            if (column == 4) //string to double 날짜 형식 변환
                            {
                                double val = Double.Parse(range.Cells[row, column].Value2.ToString());
                                DateTime conv = DateTime.FromOADate(val);
                                dr[rowCounter] = conv.ToString("yyyy/MM/dd");
                            }
                            else
                            {
                                dr[rowCounter] = range.Cells[row, column].Value2.ToString();
                            }
                        }
                        else
                        {
                            dr[row] = "";
                        }
                        rowCounter++;
                    }
                    dt.Rows.Add(dr);
                }

그럼 이런식으로...날짜 컬럼의 내용이 다섯자리 숫자가 아니라 보통 날짜 형식으로 나온다.

(Page4.xaml.cs)

namespace PracticeProject2.Views
{
    /// <summary>
    /// Page4.xaml에 대한 상호 작용 논리
    /// </summary>
    public partial class Page4 : Page
    {
        private static Page4 _Instance = null;

        public static Page4 GetInstance()
        {
            if (_Instance == null || !_Instance.IsLoaded)
            {
                _Instance = new Page4();
            }

            return _Instance;
        }

        public Page4()
        {
            InitializeComponent();

            _Instance = this;
        }
    }
}

위의 내용까지 코드 작성을 마쳤다면 Page4.xaml에서 들여오기 버튼에 Command를 Binding 한다.

(Page4.xaml)

    <Grid Grid.Column="0">
        <Button Content="들여오기" Width="100" Height="40" HorizontalAlignment="Left" Command="{Binding ImportFileCommand}"/>
    </Grid>

4. 결과

5. 참조

• https://nomadcoder.tistory.com/entry/WPF-Excel-%ED%8C%8C%EC%9D%BC-%EC%9D%BD%EC%96%B4%EC%84%9C-Datagrid-%EC%97%90-%EB%84%A3%EA%B8%B0-Excel-Import

• https://velog.io/@ansalstmd/C-알아가기-3.-C-Excel-Import-Export

• https://legacy.tistory.com/101

• https://www.freecodespot.com/blog/csharp-import-excel/

• https://learn.microsoft.com/ko-kr/dotnet/desktop/wpf/windows/how-to-open-common-system-dialog-box?view=netdesktop-7.0

• https://learn.microsoft.com/ko-kr/dotnet/api/system.windows.forms.filedialog.filter?view=windowsdesktop-7.0

• https://ghostweb.tistory.com/954

• https://learn.microsoft.com/en-us/answers/questions/939640/how-to-setup-excel-interop-for-exccel-365

• https://cwkcw.tistory.com/m/307/comments

코드 비하인드가 아닌 MVVM 패턴을 지키며 컨트롤의 이벤트를 사용하는 방법 https://velog.io/@yu_oolong/C-WPF-Button을-눌러-Frame에-Page-띄우기-2 와 같은 솔루션에서 진행

2. 개발환경

• VisualStudio 2022

3. 내용

3-1. NuGet 패키지 관리에서 Microsoft.Xaml.Behaviors.Wpf 다운로드

3-2. ICommand를 상속 받는 RelayCommand.cs 작성

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace PackagingSystem.Commands
{
    public class RelayCommand : ICommand
    {
        private readonly Action _execute;
        private readonly Func<bool> _canExecute;

        public RelayCommand(Action execute, Func<bool> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        public bool CanExecute(object parameter) => _canExecute == null || _canExecute();

        public void Execute(object parameter) => _execute();
    }

    public class RelayCommand<T> : ICommand
    {
        readonly Action<T> _execute = null;
        readonly Predicate<T> _canExecute = null;

        public RelayCommand(Action<T> execute, Predicate<T> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public bool CanExecute(object parameter)
        {
            return _canExecute?.Invoke((T)parameter) ?? true;
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        public void Execute(object parameter)
        {
            _execute((T)parameter);
        }
    }
}

3-3. Page1.xaml이 로드 될 시 동작하는 Behavior를 ViewModel에 작성

• (Page1ViewModel.cs) BaseViewModel을 상속 받는다.

  using PackagingSystem.Commands;
  using PackagingSystem.ViewModels;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.Windows;
  using System.Windows.Input;
  

namespace PracticeProject.ViewModels { internal class Page1ViewModel : BaseViewModel { public ICommand Page1LoadedCommand { get; set; }

    public Page1ViewModel() 
    {
        Page1LoadedCommand = new RelayCommand(Page1Loaded);
    }

    public void Page1Loaded()
    {
        MessageBox.Show("Page Loaded");
    }
}

}

### 3-4. Page1.xaml에 namespace 추가하고 DataContext 작성

- (Page1.xaml)
![](https://velog.velcdn.com/images/yu_oolong/post/ab5d90b1-5fef-4c75-927d-82c6c87b88bc/image.png)


```xaml
<Page x:Class="PracticeProject.Views.Page1"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      xmlns:local="clr-namespace:PracticeProject.Views"
      xmlns:vm="clr-namespace:PracticeProject.ViewModels"
      xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
      mc:Ignorable="d" 
      d:DesignHeight="450" d:DesignWidth="800"
      Title="Page1" Background="Gray">

    <Page.DataContext>
        <vm:Page1ViewModel />
    </Page.DataContext>

    <i:Interaction.Triggers>
        <i:EventTrigger EventName="Loaded">
            <i:InvokeCommandAction Command="{Binding Page1LoadedCommand}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>

    <Grid>

    </Grid>
</Page>

4. 결과

앞서 Menu1을 누르면 Page1이 로드되게 했었는데 Behavior 작성을 추가하여 Page1이 로드 되기 직전에 MessageBox가 호출된다.

MessageBox의 확인 버튼을 누르면 Page1이 로드 된다.

5. 참조

Behavior

• https://github.com/Microsoft/XamlBehaviorsWpf
• https://stpetrus27.wordpress.com/2019/02/12/c-wpf-mvvm-microsoft-xaml-behaviors-and-eventtrigger-1/
• https://m.blog.naver.com/vactorman/221176866353
• https://gomnezip.tistory.com/442
• https://kaki104.tistory.com/840
• https://kaki104.tistory.com/841

Loaded 이벤트

• https://truepia.tistory.com/278

• https://xceed.com/en/our-products/product/toolkit-plus-for-wpf/
• https://github.com/xceedsoftware/wpftoolkit
• https://github.com/xceedsoftware/wpftoolkit/wiki/Xceed-Toolkit-Plus-for-WPF

GitHub의 내용에서는 무료 Toolkit은 v4.0.0부터 비상업적 용도에 따라 제공되고 유료는 Plus Edtion이라는 것을 제공한다고 한다.

2. Visual Studio에서 설치

2-1. 솔루션용 NuGet 패키지 관리에서 Extended.Wpf.ToolKit 설치

2-2. 패키지 관리자 콘솔에서 install

1. install-Package Extended.Wpf.Toolkit 입력 후 Enter

2. App.config 파일에 아래의 내용 복사-붙여넣기

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="Xceed.Wpf.Toolkit" publicKeyToken="3e4669d2f30244f4" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-4.5.0.0" newVersion="4.5.0.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>

3. 도구 상자 항목에서 WPF 구성 요소 탭에서 찾아보기 클릭 후 프로젝트 경로/packages/Extend.Wpf.Toolkit.../lib/net40 내부의 Xceed.Wpf.Toolkit.dll을 열기 -> 확인

3. 솔루션 빌드 후 도구 상자에서 확인

만드느라 애먹었던 TextBox, PasswordBox의 PlaceHorder...같은 것들도 구현이 되어있어 편리하다. 🥹

생성할 수 있는 객체의 인스턴스를 하나로 한정하여 이미 생성된 인스턴스를 불러내 사용하기 때문에 메모리를 절약할 수 있다. 그러나 싱글톤 또한 static이기 때문에 남발하는 것이 좋지는 않다.

2. 개발환경

• VisualStudio 2022

3. Code

1. 싱글톤 패턴으로 작성할 클래스의 private static 변수
2. 만들어진 인스턴스를 외부에서 접근할 수 있는 private static 메소드
3. 외부에서 인스턴스를 생성할 수 없도록 생성자의 타입을 private으로

  private static ExSingleton _Instance = null;

  public static ExSingleton GetInstance()
  {
      if (_Instance == null)
      {
          _Instance = new ExSingleton();
      }
      return _Instance;
  }

  private ExSingleton()
  {

  }