public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        // 모든 클라이언트에게 메시지 전송
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

public async Task JoinRoom(string roomName)
{
    await Groups.AddToGroupAsync(Context.ConnectionId, roomName);
    await Clients.Group(roomName).SendAsync("UserJoined", Context.ConnectionId);
}

npm install @microsoft/signalr

var builder = WebApplication.CreateBuilder(args);

// SignalR 서비스 추가
builder.Services.AddSignalR();

var app = builder.Build();

// Hub 엔드포인트 매핑
app.MapHub<ChatHub>("/chathub");

app.Run();

using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    // 모든 사용자에게 메시지 전송
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
    
    // 특정 사용자에게만 메시지 전송
    public async Task SendPrivateMessage(string targetConnectionId, string message)
    {
        await Clients.Client(targetConnectionId).SendAsync("ReceivePrivateMessage", message);
    }
    
    // 연결 시 호출
    public override async Task OnConnectedAsync()
    {
        await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
        await base.OnConnectedAsync();
    }
    
    // 연결 해제 시 호출
    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        await Clients.All.SendAsync("UserDisconnected", Context.ConnectionId);
        await base.OnDisconnectedAsync(exception);
    }
}

<div id="chatBox">
    <div id="messages"></div>
    <input type="text" id="userInput" placeholder="이름" />
    <input type="text" id="messageInput" placeholder="메시지" />
    <button id="sendButton">전송</button>
</div>

<script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/7.0.0/signalr.min.js"></script>
<script>
    const connection = new signalR.HubConnectionBuilder()
        .withUrl("/chathub")
        .withAutomaticReconnect()
        .build();
    
    // 메시지 수신 이벤트
    connection.on("ReceiveMessage", (user, message) => {
        const msg = document.createElement("div");
        msg.textContent = `${user}: ${message}`;
        document.getElementById("messages").appendChild(msg);
    });
    
    // 연결 시작
    connection.start()
        .then(() => console.log("Connected!"))
        .catch(err => console.error(err));
    
    // 메시지 전송
    document.getElementById("sendButton").addEventListener("click", () => {
        const user = document.getElementById("userInput").value;
        const message = document.getElementById("messageInput").value;
        
        connection.invoke("SendMessage", user, message)
            .catch(err => console.error(err));
    });
</script>

public class ChatHub : Hub
{
    private static Dictionary<string, string> _userRooms = new();
    
    public async Task JoinRoom(string roomName, string userName)
    {
        // 이전 방에서 나가기
        if (_userRooms.TryGetValue(Context.ConnectionId, out var oldRoom))
        {
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, oldRoom);
            await Clients.Group(oldRoom).SendAsync("UserLeft", userName);
        }
        
        // 새 방에 입장
        await Groups.AddToGroupAsync(Context.ConnectionId, roomName);
        _userRooms[Context.ConnectionId] = roomName;
        
        await Clients.Group(roomName).SendAsync("UserJoined", userName);
        await Clients.Caller.SendAsync("JoinedRoom", roomName);
    }
    
    public async Task SendMessageToRoom(string roomName, string user, string message)
    {
        await Clients.Group(roomName).SendAsync("ReceiveMessage", user, message);
    }
    
    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        if (_userRooms.TryGetValue(Context.ConnectionId, out var room))
        {
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, room);
            _userRooms.Remove(Context.ConnectionId);
        }
        await base.OnDisconnectedAsync(exception);
    }
}

using Microsoft.AspNetCore.Authorization;

[Authorize] // 인증된 사용자만 접근 가능
public class ChatHub : Hub
{
    public async Task SendMessage(string message)
    {
        // Context.User로 현재 사용자 정보 접근
        var userName = Context.User?.Identity?.Name ?? "Anonymous";
        
        await Clients.All.SendAsync("ReceiveMessage", userName, message);
    }
    
    [Authorize(Roles = "Admin")] // 관리자만 호출 가능
    public async Task BroadcastAnnouncement(string announcement)
    {
        await Clients.All.SendAsync("ReceiveAnnouncement", announcement);
    }
}

public class DataHub : Hub
{
    public async IAsyncEnumerable<int> StreamData(
        int count, 
        int delay,
        [EnumeratorCancellation] CancellationToken cancellationToken)
    {
        for (var i = 0; i < count; i++)
        {
            cancellationToken.ThrowIfCancellationRequested();
            
            yield return i;
            
            await Task.Delay(delay, cancellationToken);
        }
    }
}

connection.stream("StreamData", 100, 100)
    .subscribe({
        next: (item) => {
            console.log(item);
        },
        complete: () => {
            console.log("Stream completed");
        },
        error: (err) => {
            console.error(err);
        }
    });

// 서버
builder.Services.AddSignalR()
    .AddMessagePackProtocol();

// 클라이언트
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub")
    .withHubProtocol(new signalR.protocols.msgpack.MessagePackHubProtocol())
    .build();

// ❌ 비효율적
await Clients.All.SendAsync("Update", data);

// ✅ 효율적
await Clients.Group("ActiveUsers").SendAsync("Update", data);

// ✅ 더 효율적
await Clients.Users(activeUserIds).SendAsync("Update", data);

public class OptimizedHub : Hub
{
    private static List<Message> _messageBuffer = new();
    private static Timer? _flushTimer;
    
    public OptimizedHub()
    {
        if (_flushTimer == null)
        {
            _flushTimer = new Timer(FlushMessages, null, 0, 100); // 100ms마다
        }
    }
    
    public void AddMessage(string user, string text)
    {
        lock (_messageBuffer)
        {
            _messageBuffer.Add(new Message { User = user, Text = text });
        }
    }
    
    private async void FlushMessages(object? state)
    {
        List<Message> toSend;
        lock (_messageBuffer)
        {
            if (_messageBuffer.Count == 0) return;
            toSend = new List<Message>(_messageBuffer);
            _messageBuffer.Clear();
        }
        
        await Clients.All.SendAsync("ReceiveBatch", toSend);
    }
}

// Redis 백플레인 사용
builder.Services.AddSignalR()
    .AddStackExchangeRedis("localhost:6379");

// Azure SignalR Service 사용
builder.Services.AddSignalR()
    .AddAzureSignalR("connection-string");

// CORS 설정 예시
builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowAll", builder =>
    {
        builder.WithOrigins("http://localhost:3000")
               .AllowAnyHeader()
               .AllowAnyMethod()
               .AllowCredentials(); // SignalR은 이게 필수!
    });
});

app.UseCors("AllowAll");

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub")
    .withAutomaticReconnect([0, 2000, 10000, 30000]) // 재연결 간격
    .configureLogging(signalR.LogLevel.Information)
    .build();

connection.onreconnecting(error => {
    console.log("재연결 시도 중...", error);
    showReconnectingUI();
});

connection.onreconnected(connectionId => {
    console.log("재연결 성공!", connectionId);
    hideReconnectingUI();
    // 필요하면 상태 복구
    rejoinRoom();
});

connection.onclose(error => {
    console.log("연결 종료", error);
    showDisconnectedUI();
});

// React 예시
useEffect(() => {
    const connection = new signalR.HubConnectionBuilder()
        .withUrl("/chathub")
        .build();
    
    const messageHandler = (user, message) => {
        setMessages(prev => [...prev, { user, message }]);
    };
    
    connection.on("ReceiveMessage", messageHandler);
    connection.start();
    
    // 클린업!
    return () => {
        connection.off("ReceiveMessage", messageHandler);
        connection.stop();
    };
}, []);

public class GameLobbyHub : Hub
{
    private static Dictionary<string, GameRoom> _rooms = new();
    private static Dictionary<string, Player> _players = new();
    
    public async Task CreateRoom(string roomName, int maxPlayers)
    {
        var room = new GameRoom
        {
            Id = Guid.NewGuid().ToString(),
            Name = roomName,
            MaxPlayers = maxPlayers,
            Players = new List<Player>()
        };
        
        _rooms[room.Id] = room;
        
        await Clients.All.SendAsync("RoomCreated", room);
    }
    
    public async Task JoinRoom(string roomId, string playerName)
    {
        if (!_rooms.TryGetValue(roomId, out var room))
        {
            await Clients.Caller.SendAsync("Error", "방을 찾을 수 없습니다");
            return;
        }
        
        if (room.Players.Count >= room.MaxPlayers)
        {
            await Clients.Caller.SendAsync("Error", "방이 가득 찼습니다");
            return;
        }
        
        var player = new Player
        {
            ConnectionId = Context.ConnectionId,
            Name = playerName,
            IsReady = false
        };
        
        room.Players.Add(player);
        _players[Context.ConnectionId] = player;
        
        await Groups.AddToGroupAsync(Context.ConnectionId, roomId);
        await Clients.Group(roomId).SendAsync("PlayerJoined", player);
        await Clients.Caller.SendAsync("JoinedRoom", room);
    }
    
    public async Task ToggleReady(string roomId)
    {
        if (!_players.TryGetValue(Context.ConnectionId, out var player))
            return;
            
        player.IsReady = !player.IsReady;
        
        await Clients.Group(roomId).SendAsync("PlayerReadyChanged", 
            Context.ConnectionId, player.IsReady);
        
        // 모든 플레이어가 준비되면 게임 시작
        if (_rooms.TryGetValue(roomId, out var room) && 
            room.Players.All(p => p.IsReady) && 
            room.Players.Count >= 2)
        {
            await Clients.Group(roomId).SendAsync("GameStarting");
        }
    }
    
    public async Task LeaveRoom(string roomId)
    {
        if (!_rooms.TryGetValue(roomId, out var room))
            return;
            
        var player = room.Players.FirstOrDefault(p => 
            p.ConnectionId == Context.ConnectionId);
            
        if (player != null)
        {
            room.Players.Remove(player);
            _players.Remove(Context.ConnectionId);
            
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, roomId);
            await Clients.Group(roomId).SendAsync("PlayerLeft", player);
            
            // 방이 비면 삭제
            if (room.Players.Count == 0)
            {
                _rooms.Remove(roomId);
                await Clients.All.SendAsync("RoomClosed", roomId);
            }
        }
    }
}

public class GameRoom
{
    public string Id { get; set; } = "";
    public string Name { get; set; } = "";
    public int MaxPlayers { get; set; }
    public List<Player> Players { get; set; } = new();
}

public class Player
{
    public string ConnectionId { get; set; } = "";
    public string Name { get; set; } = "";
    public bool IsReady { get; set; }
}

class GameLobbyClient {
    constructor() {
        this.connection = new signalR.HubConnectionBuilder()
            .withUrl("/gamelobby")
            .withAutomaticReconnect()
            .build();
        
        this.setupHandlers();
        this.connect();
    }
    
    setupHandlers() {
        this.connection.on("RoomCreated", (room) => {
            this.addRoomToList(room);
        });
        
        this.connection.on("PlayerJoined", (player) => {
            this.addPlayerToRoom(player);
            this.showNotification(`${player.Name}님이 입장했습니다`);
        });
        
        this.connection.on("PlayerReadyChanged", (connectionId, isReady) => {
            this.updatePlayerReady(connectionId, isReady);
        });
        
        this.connection.on("GameStarting", () => {
            this.showNotification("게임이 시작됩니다!", "success");
            setTimeout(() => this.startGame(), 3000);
        });
        
        this.connection.on("PlayerLeft", (player) => {
            this.removePlayerFromRoom(player);
            this.showNotification(`${player.Name}님이 퇴장했습니다`);
        });
        
        this.connection.on("Error", (message) => {
            this.showNotification(message, "error");
        });
    }
    
    async connect() {
        try {
            await this.connection.start();
            console.log("로비 연결 성공!");
        } catch (err) {
            console.error("연결 실패:", err);
            setTimeout(() => this.connect(), 5000);
        }
    }
    
    async createRoom(roomName, maxPlayers) {
        await this.connection.invoke("CreateRoom", roomName, maxPlayers);
    }
    
    async joinRoom(roomId, playerName) {
        await this.connection.invoke("JoinRoom", roomId, playerName);
    }
    
    async toggleReady(roomId) {
        await this.connection.invoke("ToggleReady", roomId);
    }
    
    async leaveRoom(roomId) {
        await this.connection.invoke("LeaveRoom", roomId);
    }
    
    // UI 업데이트 메서드들...
    addRoomToList(room) { /* ... */ }
    addPlayerToRoom(player) { /* ... */ }
    updatePlayerReady(connectionId, isReady) { /* ... */ }
    removePlayerFromRoom(player) { /* ... */ }
    showNotification(message, type = "info") { /* ... */ }
    startGame() { /* ... */ }
}

// 사용
const lobby = new GameLobbyClient();

using Microsoft.AspNetCore.SignalR.Client;

public class MobileSignalRClient
{
    private HubConnection _connection;
    
    public async Task ConnectAsync()
    {
        _connection = new HubConnectionBuilder()
            .WithUrl("https://your-server.com/chathub")
            .WithAutomaticReconnect()
            .Build();
        
        _connection.On<string, string>("ReceiveMessage", (user, message) =>
        {
            Device.BeginInvokeOnMainThread(() =>
            {
                // UI 업데이트
                Messages.Add(new ChatMessage { User = user, Text = message });
            });
        });
        
        await _connection.StartAsync();
    }
    
    public async Task SendMessageAsync(string user, string message)
    {
        await _connection.InvokeAsync("SendMessage", user, message);
    }
}

public class DesktopSignalRClient
{
    private HubConnection _connection;
    private SynchronizationContext _syncContext;
    
    public DesktopSignalRClient()
    {
        _syncContext = SynchronizationContext.Current;
    }
    
    public async Task ConnectAsync()
    {
        _connection = new HubConnectionBuilder()
            .WithUrl("https://your-server.com/chathub")
            .Build();
        
        _connection.On<string, string>("ReceiveMessage", (user, message) =>
        {
            // UI 스레드에서 실행
            _syncContext.Post(_ =>
            {
                MessageListBox.Items.Add($"{user}: {message}");
            }, null);
        });
        
        await _connection.StartAsync();
    }
}

using Microsoft.AspNetCore.SignalR.Client;
using UnityEngine;

public class UnitySignalRClient : MonoBehaviour
{
    private HubConnection _connection;
    
    async void Start()
    {
        _connection = new HubConnectionBuilder()
            .WithUrl("https://your-server.com/gamehub")
            .Build();
        
        _connection.On<Vector3>("PlayerMoved", (position) =>
        {
            // 메인 스레드에서 실행되도록
            UnityMainThreadDispatcher.Instance().Enqueue(() =>
            {
                UpdatePlayerPosition(position);
            });
        });
        
        await _connection.StartAsync();
    }
    
    public async void SendPosition(Vector3 position)
    {
        await _connection.InvokeAsync("UpdatePosition", position);
    }
    
    void OnDestroy()
    {
        _connection?.StopAsync();
    }
}

public class DashboardHub : Hub
{
    private readonly IMetricsService _metrics;
    
    public DashboardHub(IMetricsService metrics)
    {
        _metrics = metrics;
    }
    
    public async Task SubscribeToMetrics()
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, "Dashboard");
    }
    
    // 백그라운드 서비스에서 주기적으로 호출
    public async Task BroadcastMetrics()
    {
        var metrics = await _metrics.GetCurrentMetricsAsync();
        await Clients.Group("Dashboard").SendAsync("MetricsUpdate", metrics);
    }
}

public class NotificationHub : Hub
{
    public async Task SendNotification(string userId, Notification notification)
    {
        // 특정 사용자에게만 알림 전송
        await Clients.User(userId).SendAsync("ReceiveNotification", notification);
    }
    
    public async Task MarkAsRead(string notificationId)
    {
        // DB 업데이트 후
        await Clients.Caller.SendAsync("NotificationRead", notificationId);
    }
}

public class CollaborationHub : Hub
{
    public async Task JoinDocument(string documentId)
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, documentId);
        
        // 현재 편집 중인 사용자 목록 전송
        var editors = await GetActiveEditors(documentId);
        await Clients.Caller.SendAsync("ActiveEditors", editors);
    }
    
    public async Task UpdateContent(string documentId, ContentChange change)
    {
        // 자신을 제외한 다른 편집자들에게 변경사항 전송
        await Clients.OthersInGroup(documentId)
            .SendAsync("ContentChanged", change);
    }
    
    public async Task UpdateCursor(string documentId, CursorPosition position)
    {
        await Clients.OthersInGroup(documentId)
            .SendAsync("CursorMoved", Context.ConnectionId, position);
    }
}

public async Task SendMessage(string message)
{
    // 입력 검증
    if (string.IsNullOrWhiteSpace(message))
        return;
        
    if (message.Length > 500)
    {
        await Clients.Caller.SendAsync("Error", "메시지가 너무 깁니다");
        return;
    }
    
    // XSS 방지
    message = HtmlEncoder.Default.Encode(message);
    
    // SQL Injection 방지 (DB 저장 시)
    await _repository.SaveMessageAsync(message);
    
    await Clients.All.SendAsync("ReceiveMessage", message);
}

public class RateLimitedHub : Hub
{
    private static Dictionary<string, RateLimiter> _limiters = new();
    
    public async Task SendMessage(string message)
    {
        var limiter = GetOrCreateLimiter(Context.ConnectionId);
        
        if (!limiter.TryAcquire())
        {
            await Clients.Caller.SendAsync("Error", "너무 빠르게 메시지를 보내고 있습니다");
            return;
        }
        
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
    
    private RateLimiter GetOrCreateLimiter(string connectionId)
    {
        if (!_limiters.TryGetValue(connectionId, out var limiter))
        {
            // 10초에 5개 메시지까지 허용
            limiter = new RateLimiter(5, TimeSpan.FromSeconds(10));
            _limiters[connectionId] = limiter;
        }
        return limiter;
    }
}

// 클라이언트
const connection = new signalR.HubConnectionBuilder()
    .withUrl("https://your-domain.com/chathub", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    })
    .build();

public class MonitoredHub : Hub
{
    private readonly ILogger<MonitoredHub> _logger;
    private readonly IMetricsCollector _metrics;
    
    public MonitoredHub(ILogger<MonitoredHub> logger, IMetricsCollector metrics)
    {
        _logger = logger;
        _metrics = metrics;
    }
    
    public override async Task OnConnectedAsync()
    {
        _metrics.IncrementConnections();
        _logger.LogInformation("User connected: {ConnectionId}", Context.ConnectionId);
        await base.OnConnectedAsync();
    }
    
    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        _metrics.DecrementConnections();
        
        if (exception != null)
        {
            _logger.LogError(exception, "User disconnected with error: {ConnectionId}", 
                Context.ConnectionId);
        }
        
        await base.OnDisconnectedAsync(exception);
    }
    
    public async Task SendMessage(string message)
    {
        var sw = Stopwatch.StartNew();
        
        try
        {
            await Clients.All.SendAsync("ReceiveMessage", message);
            _metrics.RecordMessageSent();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to send message");
            _metrics.RecordError();
            throw;
        }
        finally
        {
            sw.Stop();
            _metrics.RecordLatency(sw.ElapsedMilliseconds);
        }
    }
}

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.AddSignalR()
    .AddApplicationInsights();

// Kubernetes에서 SignalR 사용 시
builder.Services.AddSignalR()
    .AddStackExchangeRedis(options =>
    {
        options.Configuration.EndPoints.Add("redis-service:6379");
        options.Configuration.AbortOnConnectFail = false;
    });

public class AIAssistantHub : Hub
{
    private readonly IOpenAIService _ai;
    
    public async Task AskQuestion(string question)
    {
        // 스트리밍으로 AI 응답 받기
        await foreach (var chunk in _ai.StreamResponseAsync(question))
        {
            await Clients.Caller.SendAsync("ReceiveChunk", chunk);
        }
        
        await Clients.Caller.SendAsync("ResponseComplete");
    }
}