기억상기용

[WPF][별*] Seamless, Messaging Sample

딸기우유중독 — Fri, 3 Apr 2026 09:12:22 +0900

# WPF

ComHost의 TargetFramework가 net9.0-windows 이라면
사용하는 프로젝트도 TargetFramework 가 동일해야 COM 호출 가능.

사용하는 프로젝트의 TargetFramework 가 다른 경우에 대처법.

1. 사용하는 프로젝트에 맞춰서 ComHost를 COM으로 등록한다.
2. 사용하는 프로젝트 에 맞춰서 ComHost에 TargetFramework를 추가해서 빌드 후
ex) <TargetFrameworks>net6.0-windows;net9.0-windows</TargetFrameworks>
누겟 패키지 파일로 직접 참조해서 사용한다. (COM 호출을 안한다.)

<TargetFramework>net9.0-windows</TargetFramework>

ConnectorClientCallbackActions.cs

using LS.Extension.Connector.Contract.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace LS.Extension.Connector.WpfApp.Models;

public class MessageCallback : IMessageCallback
{
    private readonly Action<string> _onMessageReceived;

    public MessageCallback(Action<string> onMessageReceived)
    {
        _onMessageReceived = onMessageReceived;
    }

    public void OnMessageReceived(string message)
    {
        _onMessageReceived?.Invoke(message);
    }
}

MainWindow.xaml.cs

this.SourceInitialized ( or Loaded 이벤트 때) 가 되어야 Handle 값 얻을 수 있음

using LS.Extension.Connector.Contract.Interfaces;
using LS.Extension.Connector.WpfApp.Models;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;

namespace LS.Extension.Connector.WpfApp;

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
    public static IChildClient ChildClient { get; private set; } = new ChildClient(); 
    public static IParentClient ParentClient { get; private set; } = new ParentClient();

    public string ThemeName { get; set; } = string.Empty;

    public MainWindow()
    {
        InitializeComponent();
        ParentClient.SetArguments(App.Args);
        var connectorId = ParentClient.GetConnectorId();
        if (!string.IsNullOrEmpty(connectorId))
        {
            try
            {
                this.SourceInitialized += AttachClient;
            }
            catch (Exception)
            {
                throw;
            }
        }
        //else
        {
            this.SourceInitialized += RegisterClient;
        }
    }
    #region ParentClient

    private void AttachClient(object? sender, EventArgs e)
    {
        string themeName = App.Args[3]?.Replace("/themeName=", "").Trim() ?? string.Empty;

        if (!string.IsNullOrEmpty(themeName))
        {
            MainGrid.Background = Brushes.AntiqueWhite;
            ThemeName = string.Empty;
        }
        else
        {
            MainGrid.Background = Brushes.AliceBlue;
            ThemeName = "Default";
        }
        var controlHandle = new WindowInteropHelper(this).Handle;
        ParentClient.AttachClient(controlHandle);
        ParentConnectorId.Text = $"Connector ID: {ParentClient.GetConnectorId()}";
    }

    private void SendMessageToParentButton(object sender, RoutedEventArgs e)
    {
        ParentClient.SendMessage(ParentKeyTextBox.Text, ParentMessageTextBox.Text);
    }
    private void GetMessageFromParentButton(object sender, RoutedEventArgs e)
    {
        ParentMessage.Text = ParentClient.GetMessage(ParentKeyTextBox.Text);
    }
    private void SubscribeParentMessageButton(object sender, RoutedEventArgs e)
    {
        var key = ParentKeyTextBox.Text;
        var callback = new MessageCallback((message) =>
        {
            Dispatcher.Invoke(() =>
            {
                ParentMessage.Text = $"[{key}] Received: {message}";
            });
        });
        ParentClient.SubscribeMessage(key, callback);
    }
    private void NewAttachClientButton(object sender, RoutedEventArgs e)
    {
        IParentClient newParentClient = new ParentClient();
        newParentClient.SetArguments(new string[] { "",NewConnectorIdTextBox.Text,"","","","" });
        newParentClient.AttachClient(new WindowInteropHelper(this).Handle);
        ParentClient = newParentClient;
        ParentConnectorId.Text = $"Connector ID: {ParentClient.GetConnectorId()}";
    }
    

    #endregion ParentClient

    #region ChildClient

    private void StartChildAppButton(object sender, RoutedEventArgs e)
    {
        //ChildClient.StartProcess("C:\\Users\\iskim\\Downloads\\XG5000_Release_2026_01_07_Bridge\\EngCopilot\\LS.CommonUI.EngSearch.Host.exe");
        //ChildClient.StartProcess("D:\\GitLab\\Services\\Extension\\connector\\LS.Extension.Connector\\LS.Extension.Connector.WpfApp\\bin\\x64\\Debug\\net9.0-windows\\LS.Extension.Connector.WpfApp.exe");
        ChildClient.StartProcess("D:\\GitLab\\Services\\Extension\\connector\\LS.Extension.Connector\\LS.Extension.Connector.WpfApp\\bin\\x86\\Debug\\net9.0-windows\\LS.Extension.Connector.WpfApp.exe");
    }

    private void RegisterClient(object? sender, EventArgs e)
    {
        var controlHandle = childWindowHost.GetHostHandle();
        ChildClient.RegisterClient(controlHandle.ToString(), themeName: ThemeName);
        //ChildClient.RegisterClient(themeName: ThemeName);
        ChildConnectorId.Text = $"Connector ID: {ChildClient.GetConnectorId()}";
    }

    private void SendMessageToChildButton(object sender, RoutedEventArgs e)
    {
        ChildClient.SendMessage(ChildKeyTextBox.Text, ChildMessageTextBox.Text);
    }
    private void GetMessageFromChildButton(object sender, RoutedEventArgs e)
    {
        ChildMessage.Text = ChildClient.GetMessage(ChildKeyTextBox.Text);
    }

    private void SubscribeChildMessageButton(object sender, RoutedEventArgs e)
    {
        var key = ChildKeyTextBox.Text;

        var callback = new MessageCallback((message) =>
        {
            Dispatcher.Invoke(() =>
            {
                ChildMessage.Text = $"[{key}] Received: {message}";
            });
        });

        ChildClient.SubscribeMessage(key, callback);
    }
    private void NewConnectorButton(object sender, RoutedEventArgs e)
    {
        IChildClient newChildClient = new ChildClient();
        newChildClient.RegisterClient();
        ChildClient = newChildClient;
        NewChildConnectorId.Text = $"/connectorId={ChildClient.GetConnectorId()}";
        ChildConnectorId.Text = $"Connector ID: {ChildClient.GetConnectorId()}";
    }
    

    #endregion ChildClient
}

ChildWindowHost.cs

WPF는 기본적으로 최상위 Root 트리로 Window를 두고 밑으로 UserControl를 두고 있음.
Seamless에 원하는 영역으로 ParentWindowHandle을 주기 위해서 아래와 같이 컨트롤 추가

MainWindow.xaml

using System;
using System.Runtime.InteropServices;
using System.Windows.Interop;

namespace LS.Extension.Connector.WpfApp.Controls;

public class ChildWindowHost : HwndHost
{
    private IntPtr _hwndHost;

    protected override HandleRef BuildWindowCore(HandleRef hwndParent)
    {
        _hwndHost = CreateWindowEx(
            0, "Static", "",
            WS_CHILD | WS_VISIBLE,
            0, 0,
            0, 0,
            hwndParent.Handle,
            IntPtr.Zero,
            IntPtr.Zero,
            IntPtr.Zero);

        return new HandleRef(this, _hwndHost);
    }

    protected override void DestroyWindowCore(HandleRef hwnd)
    {
        DestroyWindow(hwnd.Handle);
    }

    public IntPtr GetHostHandle()
    {
        return _hwndHost;
    }

    #region Win32 API

    private const int WS_CHILD = 0x40000000;
    private const int WS_VISIBLE = 0x10000000;

    [DllImport("user32.dll", EntryPoint = "CreateWindowEx", CharSet = CharSet.Unicode)]
    private static extern IntPtr CreateWindowEx(
        int dwExStyle,
        string lpszClassName,
        string lpszWindowName,
        int style,
        int x, int y,
        int width, int height,
        IntPtr hwndParent,
        IntPtr hMenu,
        IntPtr hInst,
        IntPtr pvParam);

    [DllImport("user32.dll", EntryPoint = "DestroyWindow", CharSet = CharSet.Unicode)]
    private static extern bool DestroyWindow(IntPtr hwnd);

    #endregion
}

# MFC

Contract.dll 로부터 .tlb 파일 얻은 후 .h 파일로 변환.

MessageCallbackHandler.h

CoCreateFreeThreadedMarshaler 이걸 해줘야 .net COM 마샬링 호출이 가능함.

#pragma once

#include "LS.Extension.Connector.Contract.h"
#include <atlbase.h>
#include <atlcom.h>
#include <atomic>
#include <afxwin.h>

// CMessageCallbackHandler class for handling IMessageCallback
class CMessageCallbackHandler : public IMessageCallback
{
public:
    CMessageCallbackHandler(CStatic* pLabelResult) 
        : m_pLabelResult(pLabelResult)
        , m_pFreeThreadedMarshaler(nullptr)
        , m_bInitialized(false)
    {
    }

    // Initialize method to be called after construction
    HRESULT Initialize()
    {
        if (m_bInitialized)
            return S_OK;

        // Create Free-Threaded Marshaler to enable cross-apartment marshaling
        HRESULT hr = CoCreateFreeThreadedMarshaler(static_cast<IMessageCallback*>(this), &m_pFreeThreadedMarshaler);
        if (SUCCEEDED(hr))
        {
            m_bInitialized = true;
        }
        return hr;
    }

    // IMessageCallback method
    STDMETHODIMP OnMessageReceived(BSTR message) override
    {
        if (!message)
            return E_POINTER;

        // Directly convert BSTR to CString without using _bstr_t
        CString strMessage;
        strMessage.Format(_T("Message received: %s"), CString(message));

        if (m_pLabelResult && m_pLabelResult->GetSafeHwnd())
        {
            m_pLabelResult->SetWindowText(strMessage);
        }

        return S_OK;
    }

    // IUnknown methods
    STDMETHODIMP QueryInterface(REFIID riid, void** ppv)
    {
        if (!ppv) return E_POINTER;

        if (riid == IID_IUnknown || riid == IID_IDispatch || riid == __uuidof(IMessageCallback))
        {
            *ppv = static_cast<IMessageCallback*>(this);
            AddRef();
            return S_OK;
        }

        // Delegate to Free-Threaded Marshaler for IMarshal interface
        if (riid == IID_IMarshal)
        {
            // Lazy initialization of Free-Threaded Marshaler
            if (!m_bInitialized)
            {
                Initialize();
            }

            if (m_pFreeThreadedMarshaler)
            {
                return m_pFreeThreadedMarshaler->QueryInterface(riid, ppv);
            }
        }

        *ppv = nullptr;
        return E_NOINTERFACE;
    }

    STDMETHODIMP_(ULONG) AddRef() override
    {
        return ++m_refCount;
    }

    STDMETHODIMP_(ULONG) Release() override
    {
        ULONG newCount = --m_refCount;
        if (newCount == 0) delete this;
        return newCount;
    }

    // IDispatch methods (stubs for simplicity)
    STDMETHODIMP GetTypeInfoCount(UINT* pctinfo)
    {
        *pctinfo = 0;
        return S_OK;
    }

    STDMETHODIMP GetTypeInfo(UINT /*iTInfo*/, LCID /*lcid*/, ITypeInfo** /*ppTInfo*/)
    {
        return E_NOTIMPL;
    }

    STDMETHODIMP GetIDsOfNames(REFIID /*riid*/, LPOLESTR* /*rgszNames*/, UINT /*cNames*/, LCID /*lcid*/, DISPID* /*rgDispId*/)
    {
        return E_NOTIMPL;
    }

    STDMETHODIMP Invoke(DISPID /*dispIdMember*/, REFIID /*riid*/, LCID /*lcid*/, WORD /*wFlags*/, DISPPARAMS* /*pDispParams*/, VARIANT* /*pVarResult*/, EXCEPINFO* /*pExcepInfo*/, UINT* /*puArgErr*/)
    {
        return E_NOTIMPL;
    }

private:
    ~CMessageCallbackHandler() 
    {
        if (m_pFreeThreadedMarshaler)
        {
            m_pFreeThreadedMarshaler->Release();
            m_pFreeThreadedMarshaler = nullptr;
        }
    }

    std::atomic<ULONG> m_refCount{ 1 };
    CStatic* m_pLabelResult;
    IUnknown* m_pFreeThreadedMarshaler;
    bool m_bInitialized;
};

호출 사용 예시

객체 인스턴스 생성

IChildClient* m_pChildClient;

HRESULT hr = CoCreateInstance(__uuidof(ChildClientClass), nullptr, CLSCTX_INPROC_SERVER, __uuidof(IChildClient), (void**)&m_pChildClient);

인터페이스 호출 해서 사용.
m_pChildClient->RegisterClient(bstrHwnd);
m_pChildClient->StartProcess(bstrPath);

void CLSExtensionConnectorMfcAppDlg::OnBnClickedButton1()
{
	// TODO: Add your control notification handler code here
	CWaitCursor wait;

	CoInitialize(NULL);
	try
	{
		if (m_pChildClient == nullptr)
		{
			HRESULT hr = CoCreateInstance(__uuidof(ChildClientClass), nullptr, CLSCTX_INPROC_SERVER, __uuidof(IChildClient), (void**)&m_pChildClient);

			if (FAILED(hr) || m_pChildClient == nullptr)
			{
				AfxMessageBox(_T("COM 객체 생성 실패"));
				CoUninitialize();
				return;
			}
		}

		CString strResult;

		BSTR bstrPath = ::SysAllocString(L"D:\\GitLab\\Services\\Extension\\connector\\LS.Extension.Connector\\LS.Extension.Connector.WpfApp\\bin\\x64\\Debug\\net9.0-windows\\LS.Extension.Connector.WpfApp.exe");
		//BSTR bstrPath = ::SysAllocString(L"C:\\Users\\iskim\\Downloads\\XG5000_Release_2026_01_07_Bridge\\EngCopilot\\LS.CommonUI.EngSearch.Host.exe");

		HWND rightHwnd = m_wndRight.GetSafeHwnd();
		strResult.Format(L"%d", (UINT_PTR)rightHwnd);
		BSTR bstrHwnd = ::SysAllocString(strResult);
		m_pChildClient->RegisterClient(bstrHwnd);
		::SysFreeString(bstrHwnd);

		m_pChildClient->StartProcess(bstrPath);
		::SysFreeString(bstrPath);

		BSTR bstrKey = ::SysAllocString(L"TestKey");
		BSTR bstrMsg = ::SysAllocString(L"Hello from MFC Parent Client!");
		m_pChildClient->SendMessageW(bstrKey, bstrMsg);
		::SysFreeString(bstrKey);
		::SysFreeString(bstrMsg);
	}
	catch (...)
	{
		AfxMessageBox(_T("알 수 없는 예외 발생"));
	}

	CoUninitialize();
}

[C#] gRPC Proto

딸기우유중독 — Mon, 23 Mar 2026 16:50:11 +0900

https://protobuf.dev/programming-guides/proto3/

Dictionary<k,v>

[Blazor] wwwroot

딸기우유중독 — Wed, 11 Mar 2026 11:17:41 +0900

[VS] Nuget Package 수동 추가

딸기우유중독 — Wed, 11 Mar 2026 10:28:53 +0900

패키지 경로

D:\PlayGround\WpfApp1\BlazorButtonLib.Wpf\bin\Debug

추가하고자 하는 프로젝트 폴더로 이동 후 아래 명령어 실행.

EX)

dotnet add package BlazorButtonLib.Wpf --version 1.0.2 --source "D:\PlayGround\WpfApp1\BlazorButtonLib.Wpf\bin\Debug"

[VS][별*] Github Copilot MCP 사용

딸기우유중독 — Tue, 10 Mar 2026 16:44:49 +0900

아래 Github Copilot MCP tools 가 있어야 Agent 모드로 알아서 파일 지지고 볶는 행위를 함.

그냥 솔루션 만들면 안들어가있고

아마도 Git clone하면 아래처럼 Solution 폴더 안에 .mcp.json으로 생성하는것 같은데 ( 추정. 확인 해봐야 함.)

여튼 로컬에서 새로만든 solution 프로젝트에서도 사용하고 싶으면

사용자 폴더에 있는 Global .mcp.json 에 Server 로 추가해 줘야 함.

아래 처럼 직접 추가해서 수정해주고 저장.

.mcp.json

{
  "inputs": [],
  "servers": {
 
"github": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_pat}"
      }
    }

  }
}

[DX_WPF] AI Chat Control

딸기우유중독 — Thu, 18 Dec 2025 09:03:05 +0900

view

<UserControl x:Class="LS.CommonUI.EngSearch.Com.Views.EngCopilotView"
             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:dxmvvm="http://schemas.devexpress.com/winfx/2008/xaml/mvvm" 
             xmlns:ViewModels="clr-namespace:LS.CommonUI.EngSearch.Com.ViewModels" 
             xmlns:dxaichat="http://schemas.devexpress.com/winfx/2008/xaml/aichat" 
             xmlns:chat="clr-namespace:DevExpress.AIIntegration.Blazor.Chat;assembly=DevExpress.AIIntegration.Blazor.Chat.v25.2"
             xmlns:system="clr-namespace:System;assembly=mscorlib"
             mc:Ignorable="d"
             d:DesignHeight="300" d:DesignWidth="600">
    <Grid>
        <dxaichat:AIChatControl x:Name="aiChatControl"
            ContentFormat="Markdown" 
            UseStreaming="True"
            InputEnabled="True"
            FileUploadEnabled="True"
            HorizontalAlignment="Stretch" 
            VerticalAlignment="Stretch" 
            Margin="10">

            <dxmvvm:Interaction.Behaviors>
                <dxmvvm:EventToCommand 
                        SourceName="aiChatControl"
                        EventName="MarkdownConvert" 
                        Command="{Binding MarkdownConvertCommand}"
                        PassEventArgsToCommand="True"/>
                <dxmvvm:EventToCommand 
                        SourceName="aiChatControl"
                        EventName="MessageSent" 
                        Command="{Binding MessageSentCommand}"
                        PassEventArgsToCommand="True"/>
            </dxmvvm:Interaction.Behaviors>
            
            <dxaichat:AIChatControl.FileUploadSettings>
                <chat:DxAIChatFileUploadSettings MaxFileSize="5000000" MaxFileCount="5">
                    <chat:DxAIChatFileUploadSettings.AllowedFileExtensions>
                        <system:String>.png</system:String>
                        <system:String>.pdf</system:String>
                        <system:String>.txt</system:String>
                    </chat:DxAIChatFileUploadSettings.AllowedFileExtensions>
                    <chat:DxAIChatFileUploadSettings.FileTypeFilter>
                        <system:String>image/png</system:String>
                        <system:String>application/pdf</system:String>
                        <system:String>text/plain</system:String>
                    </chat:DxAIChatFileUploadSettings.FileTypeFilter>
                </chat:DxAIChatFileUploadSettings>
            </dxaichat:AIChatControl.FileUploadSettings>
            <dxaichat:AIChatControl.PromptSuggestions>
                <chat:DxAIChatPromptSuggestion
            Title="Birthday Wish"
            Text="A warm and cheerful birthday greeting message."
            PromptMessage="Write a heartfelt birthday message for a close friend." />
                <chat:DxAIChatPromptSuggestion
            Title="Thank You Note"
            Text="A polite thank you note to express gratitude."
            PromptMessage="Compose a short thank you note to a colleague who helped with a project." />
            </dxaichat:AIChatControl.PromptSuggestions>
        </dxaichat:AIChatControl>
    </Grid>
</UserControl>

viewModel

using Azure.AI.OpenAI;
using DevExpress.AIIntegration;
using DevExpress.AIIntegration.Blazor.Chat.WebView;
using DevExpress.Data.Utils;
using DevExpress.Mvvm;
using LS.CommonUI.EngSearch.Com.Models;
using Microsoft.AspNetCore.Components;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Client;
using OpenAI.Chat;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
using ChatMessage = Microsoft.Extensions.AI.ChatMessage;

namespace LS.CommonUI.EngSearch.Com.ViewModels;

public class EngCopilotViewModel : ViewModelBase
{
    public string Header { get; set; } = "XGPilot";
    IChatClient asChatClient = null;
    List<Microsoft.Extensions.AI.ChatMessage> messages = [];

    public EngCopilotViewModel()
    {
        RegisterAIChatClient();
        //var tools = GetMCPToolTest();
        //ApplyToolsToChatClient();

       
    }

    private DelegateCommand<object> markdownConvertCommand;
    public DelegateCommand<object> MarkdownConvertCommand =>
        markdownConvertCommand ?? (markdownConvertCommand = new DelegateCommand<object>(ExecuteMarkdownConvertCommand));
    void ExecuteMarkdownConvertCommand(object obj)
    {
        var e = obj as AIChatControlMarkdownConvertEventArgs;
        e.HtmlText = (MarkupString)Markdig.Markdown.ToHtml(e.MarkdownText);
    }

    private DelegateCommand<object> messageSentCommand;
    public DelegateCommand<object> MessageSentCommand =>
        messageSentCommand ?? (messageSentCommand = new DelegateCommand<object>(ExecuteMessageSentCommand));
    async void ExecuteMessageSentCommand(object obj)
    {
        var e = obj as AIChatControlMessageSentEventArgs;
        var message = e.Content;

        var messages = await ApplyToolsToChatClient(message, e);

        //await e.SendMessage(, ChatRole.Assistant);
    }



    async Task<IList<McpClientTool>> GetMCPToolTest()
    {
        var client = McpClientCollection.GetAxMcpClient();
        var tools = await client.ListToolsAsync();
        return tools;
    }


    async Task<List<ChatMessage>> ApplyToolsToChatClient(string message, AIChatControlMessageSentEventArgs eventArgs)
    {
        //Console.Write("Q: ");
        messages.Add(new(ChatRole.User, message));

        List<ChatResponseUpdate> updates = [];
        string updateText = string.Empty;
        var tools = await GetMCPToolTest();
        await foreach (var update in asChatClient.GetStreamingResponseAsync(messages, new() { Tools = [.. tools] }))
        {
            updateText += update.Text;
            updates.Add(update);
        }
        await eventArgs.SendMessage(updateText, ChatRole.Assistant);

        //messages.Clear();
        messages.AddMessages(updates);
        return Task.FromResult(messages).Result;
    }

    private void RegisterAIChatClient()
    {
        string azureOpenAIEndpoint = "https://iskimls.openai.azure.com/";
        string azureOpenAIKey = "3XP9Nm6azrubLH0LTc8UmMvpZcVRYFTGF4rO1ywWhb4QQxlWGsQiJQQJ99BLACHYHv6XJ3w3AAABACOGjeb3";
        string deployment = "gpt-5-chat";

        var container = AIExtensionsContainerDesktop.Default;

        asChatClient = new ChatClientBuilder( 
            new AzureOpenAIClient(new Uri(azureOpenAIEndpoint),
                new System.ClientModel.ApiKeyCredential(azureOpenAIKey))
            .GetChatClient(deployment).AsIChatClient() 
            ).UseDXTools()
            .UseFunctionInvocation()
            .Build(container);

        container.RegisterChatClient(asChatClient);

    }
}

asChatClient = new ChatClientBuilder( ... )

ChatClientBuilder 사용해야 GetStreamingResponseAsync 에서 오류 안남.

# MessageSent

  <dxmvvm:EventToCommand 
          SourceName="aiChatControl"
          EventName="MessageSent" 
          Command="{Binding MessageSentCommand}"
          PassEventArgsToCommand="True"/>


    private DelegateCommand<object> messageSentCommand;
    public DelegateCommand<object> MessageSentCommand =>
        messageSentCommand ?? (messageSentCommand = new DelegateCommand<object>(ExecuteMessageSentCommand));
    async void ExecuteMessageSentCommand(object obj)
    {
        var e = obj as AIChatControlMessageSentEventArgs;
        var message = e.Content;

        var messages = await ApplyToolsToChatClient(message, e);

    }

AI Chat Control에서 prompt 입력시 Message를 기존 DevExpress 로직이 아니라 Custom 해서 Reply 가능하게 함.

# 직접 Reply를 얻어서 반환해줘야 함.

MessageSent 사용시 기존 AIChatControl과의 호환성 문제 있음.

Ex) ChatResources 적용 안된다던가..

https://docs.devexpress.com/WPF/405434/ai-powered-extensions/ai-chat-control?v=25.2&utm_source=SupportCenter&utm_medium=mail&utm_campaign=docs-feedback&utm_content=T1316946#tool-calling

AI Chat Control | WPF Controls | DevExpress Documentation

Developer documentation for all DevExpress products.

docs.devexpress.com

https://docs.devexpress.com/WPF/405613/ai-powered-extensions/ai-chat-control/resources?v=25.2&utm_source=SupportCenter&utm_medium=mail&utm_campaign=docs-feedback&utm_content=T1316946

Chat Resources | WPF Controls | DevExpress Documentation

Developer documentation for all DevExpress products.

docs.devexpress.com

https://docs.devexpress.com/CoreLibraries/405585/ai-integration/ai-tool-calling?v=25.2&utm_source=SupportCenter&utm_medium=mail&utm_campaign=docs-feedback&utm_content=T1316946

Tool Calling (AI Chat Control) | Cross-Platform Class Library | DevExpress Documentation

Developer documentation for all DevExpress products.

docs.devexpress.com

[VS] build bug, Error

딸기우유중독 — Mon, 15 Dec 2025 11:39:17 +0900

# Visual Studio 에서 git branch 바꾸면서 build시 빌드결과물이 제대로 안나오는 버그있음.

Ex)

A패키지 포함하는 브랜치 빌드 후

A패키지 포함하지 않는 브랜치 넘어와서 빌드 시

A패키지 포함되어서 빌드되는 경우.

# Sol

VS 재시작.

[C#] HttpClient

딸기우유중독 — Tue, 9 Dec 2025 15:45:43 +0900

# Error

https://keistory.tistory.com/1735

The SSL connection could not be established, see inner exception

HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return true; };
HttpClient httpClient = new HttpClient(clientHandler);

Ex)

McpClient 생성

[WPF] Http Server

딸기우유중독 — Mon, 1 Dec 2025 09:05:51 +0900

https://hwanstory.kr/@kim-hwan/posts/run-a-simple-http-web-server-in-dotnet-wpf

.Net WPF 에서 간단하게 Http 웹서버 실행하기

.Net8 WPF 윈도우 응용프로그램에서 Http 웹서버 기능을 제공하기 위해 여러가지 간단한 Http 구현체를 사용할 수 있다.

hwanstory.kr

[AI] IChatClient

딸기우유중독 — Wed, 26 Nov 2025 10:57:45 +0900

https://learn.microsoft.com/ko-kr/agent-framework/user-guide/agents/agent-types/chat-client-agent?pivots=programming-language-csharp

어떤 IChatClient을/를 기반으로 한 에이전트

IChatClient 구현에서 Microsoft 에이전트 프레임워크를 사용하는 방법을 알아봅니다.

learn.microsoft.com

https://learn.microsoft.com/ko-kr/dotnet/ai/quickstarts/build-mcp-client

빠른 시작 - .NET을 사용하여 최소 MCP 클라이언트 만들기 - .NET

최소 MCP 클라이언트를 만들고 .NET을 사용하여 MCP 서버에 연결하는 방법을 알아봅니다.

learn.microsoft.com