C# Switch 식(Expression)

C# 8.0(2019년 9월)부터 도입된 Switch 식(Switch Expression)은 기존의 switch-case 문을 획기적으로 줄여주는 강력한 기능

람다 표현식(=>)을 쓰는 것처럼 간결하고 직관적인 분기 처리가 가능

기존 방식 (Statement)

public string GetGrade(int score)
{
    string grade;
    switch (score)
    {
        case 90:
            grade = "A";
            break;
        case 80:
            grade = "B";
            break;
        default:
            grade = "C";
            break;
    }
    return grade;
}

새로운 방식 (Expression)

public string GetGrade(int score) => score switch
{
    90 => "A",
    80 => "B",
    _  => "C"
};


또는 다른 범위 방식으로 (결과는 다름) 
score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _     => "D"
};

• 위치 이동: switch 키워드가 변수 뒤로 이동 (score switch)
• 화살표 사용: case ... : 대신 람다 화살표 =>를 사용
• Default 처리: default: 대신 와일드카드 _를 사용
• 식(Expression): 그 자체가 ‘값’을 반환하므로 메서드의 리턴값으로 바로 사용할 수 있음

강력한 활용 패턴

C# 9.0(2020년 11월)부터 Switch 식이 단순 매핑이 아니라 패턴 매칭(Pattern Matching)과 결합됨

• Switch Expression 자체는 C# 8에서 처음 도입
• Pattern Matching 자체는 C# 7부터 지원
• Relational Pattern, Logical Pattern 등이 C# 9에서 추가

범위 비교 (Relational Pattern)

C# 9.0부터는 when 키워드 없이도 관계 연산자를 직접 사용

int temperature = 28;

string weather = temperature switch
{
    >= 30 => "폭염",
    >= 20 => "쾌적함",
    >= 10 => "쌀쌀함",
    _     => "추움"
};

여러 변수 동시에 비교 (Tuple Pattern)

두 개 이상의 상태를 조합해서 분기해야 할 때, if-else 중첩 없이 튜플 패턴으로 깔끔하게 해결

string state = "Running";
bool hasError = true;

// (상태, 에러여부)를 한 번에 검사
string message = (state, hasError) switch
{
    ("Running", false) => "정상 작동 중",
    ("Running", true)  => "작동 중이나 오류 발생",
    ("Stopped", _)     => "시스템 중지됨", // _는 true/false 상관없음
    _                  => "알 수 없는 상태"
};

객체 속성 비교 (Property Pattern)

객체 내부의 특정 프로퍼티 값에 따라 분기할 수도 있음

var user = new User { Role = "Admin", IsDeleted = false };

string accessLevel = user switch
{
    { Role: "Admin", IsDeleted: false } => "관리자 권한",
    { Role: "User", IsDeleted: false }  => "일반 사용자",
    { IsDeleted: true }                 => "삭제된 계정",
    _                                   => "접근 불가" // null 포함
};

// 객체가 null인 경우도 자동으로 _

리턴값이 없는 메서드(Action) 실행

Action 델리게이트를 반환받아 즉시 실행

switch expression은 “값”을 반환하므로 델리게이트(함수 포인터)를 반환하는 것도 가능

int command = 1;

// 1. 각 조건에 맞는 Action(행동)을 선택하고
// 2. 마지막의 ()로 즉시 실행합니다.
(command switch
{
    1 => (Action)(() => SaveData()),
    2 => () => LoadData(),
    _ => () => Console.WriteLine("대기")
})(); 
// 마지막 ()는 "반환된 델리게이트 실행"

The post C# Switch 식(Expression) appeared first on 어제와 내일의 나 그 사이의 이야기.

1⃣ 사용자가 “Google로 로그인” 버튼을 클릭

Navigation.NavigateTo(..., forceLoad: true)

Blazor의 내부 라우팅이 아닌, 브라우저가 직접 해당 URL(api/auth/Challenge/Google...)로 GET 요청보낸다.

private void LoginWithGoogle()
{
    var returnUrl = "/"; // 로그인 성공 후 돌아올 주소
    var googleLoginUrl = $"/api/auth/Challenge/Google?returnUrl={Uri.EscapeDataString(returnUrl)}";

    // 이 주소로 브라우저가 페이지를 새로고침하며 이동
    Navigation.NavigateTo(googleLoginUrl, forceLoad: true);
}

2⃣ 백엔드의 인증 시작 (AuthController – Challenge)

// AuthController.cs
[HttpGet("Challenge/{provider}")]
public IActionResult Challenge(string provider, string? returnUrl = null)
{
    // ...
    var redirectUrl = Url.Action("Callback", "Auth", ...); // 1. Google이 인증 후 돌아올 우리 API 주소(Callback)를 지정
    var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl); // 2. 인증 요청에 필요한 속성 구성

    return Challenge(properties, provider); // 3. Google 로그인 페이지로 리디렉션하는 응답 생성
}

• AuthController.cs의 Challenge 메서드가 실행됩니다.
  provider 매개변수에는 “Google”이 전달
• _signInManager는 ASP.NET Core Identity의 핵심 기능으로, 외부 로그인 과정을 도와줌
• return Challenge(properties, provider);는 브라우저에게 HTTP 302 Redirect 응답을 보냄
  이 응답 헤더에는 사용자가 이동해야 할 Google의 로그인 페이지 주소가 포함

3⃣ 외부 공급자 인증 (Google)

사용자는 Google 로그인 페이지로 이동

• 사용자는 자신의 Google 계정으로 로그인하고, 우리 애플리케이션이 요청하는 정보(이메일, 프로필 등)에 대한 접근 권한을 허용
• 인증이 성공적으로 완료되면, Google은 2단계에서 백엔드가 지정했던 콜백 URL(api/Auth/Callback)로 사용자를 다시 리디렉션
  이때 인증 코드 또는 토큰과 함께 사용자를 보냄

4⃣ 백엔드의 콜백 처리 및 로그인/회원가입 (AuthController – Callback)

Google이 사용자를 우리 백엔드의 Callback 엔드포인트로 돌려보냄

AuthController.cs의 Callback (라우팅 경로: externalLogin) 메서드가 실행

// AuthController.cs
[HttpGet("externalLogin")]
public async Task<IActionResult> Callback(...)
{
    // 1. Google이 보내준 정보로 외부 로그인 정보를 가져옴
    var info = await _signInManager.GetExternalLoginInfoAsync();
    if (info == null) { /* 에러 처리 */ }

    // 2. 이 외부 정보(공급자, 키)로 우리 DB에 연결된 사용자가 있는지 확인하고 로그인 시도
    var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, ...);

    if (result.Succeeded)
    {
        // 3a. 성공! 이미 가입하고 연동된 사용자. 로그인 처리 후 returnUrl로 리디렉션
        return LocalRedirect(returnUrl);
    }
    else
    {
        // 3b. 실패. 신규 사용자이거나, 이메일은 같지만 연동되지 않은 사용자.
        return await HandleUserCreationOrLinking(info, returnUrl);
    }
}

HandleUserCreationOrLinking 메서드는 다음 두 가지 시나리오를 처리

• 시나리오 A: 이메일은 존재하지만 소셜 연동이 안 된 경우 (LinkExistingUser)
  • Google에서 받은 이메일로 우리 DB에서 사용자를 찾습니다. (_userManager.FindByEmailAsync)
  • 기존 사용자가 있다면, 해당 계정에 이 Google 로그인 정보를 추가로 연결합니다. (_userManager.AddLoginAsync)
  • 연결 후, 사용자를 로그인시키고 returnUrl로 리디렉션합니다.
• 시나리오 B: 완전히 새로운 사용자인 경우 (CreateNewUserAsync)
  • Google에서 받은 이메일과 이름으로 새로운 ApplicationUser 객체를 만듭니다. 이때 EmailConfirmed는 true로 설정합니다. (소셜 로그인은 이미 이메일이 인증된 것으로 간주)
  • _userManager.CreateAsync(user)로 DB에 새 사용자를 저장합니다.
  • 새로 생성된 사용자 계정에 Google 로그인 정보를 연결합니다. (_userManager.AddLoginAsync)
  • 새 사용자를 로그인시키고 returnUrl로 리디렉션합니다.

5⃣ 완료

로그인 또는 회원가입 및 연동이 모두 성공적으로 끝나면, 백엔드는 최종적으로 LocalRedirect(returnUrl)을 통해 사용자를 맨 처음 Login.razor에서 지정했던 주소(/)로 리디렉션합니다.

이제 사용자는 로그인된 상태로 메인 페이지를 보게 됩니다.

6⃣ AuthController.cs

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.IdentityModel.Tokens;
using Neco.BaseTemplate.Shared.Data;
using Neco.BaseTemplete.Data;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using System.Text.Encodings.Web;

namespace Neco.BaseTemplete.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class AuthController : ControllerBase
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly IUserStore<ApplicationUser> _userStore;
        private readonly IEmailSender<ApplicationUser> _emailSender;
        private readonly ILogger<AuthController> _logger;

        public AuthController(
            UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            IUserStore<ApplicationUser> userStore,
            IEmailSender<ApplicationUser> emailSender,
            ILogger<AuthController> logger)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _userStore = userStore;
            _emailSender = emailSender;
            _logger = logger;
        }

        #region Basic Authentication

        /// <summary>
        /// Handles user login.
        /// </summary>
        /// <param name="model">Login request DTO (email, password, RememberMe option)</param>
        /// <returns>The login result</returns>
        [HttpPost("login")]
        public async Task<IActionResult> Login([FromBody] LoginUserRequestDTO model)
        {
            try
            {
                var result = await _signInManager.PasswordSignInAsync(
                    model.Email,
                    model.Password,
                    model.RememberMe,
                    lockoutOnFailure: true);

                if (result.Succeeded)
                {
                    _logger.LogInformation("User logged in: {Email}", model.Email);
                    return Ok(new { Success = true });
                }

                if (result.RequiresTwoFactor)
                {
                    return Ok(new { RequiresTwoFactor = true });
                }

                if (result.IsLockedOut)
                {
                    _logger.LogWarning("User account locked out: {Email}", model.Email);
                    return BadRequest("Account locked out");
                }

                return BadRequest("Invalid login attempt");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Login error for {Email}", model.Email);
                return StatusCode(500, "An error occurred");
            }
        }

        /// <summary>
        /// Handles new user registration.
        /// </summary>
        /// <param name="model">Registration request DTO</param>
        /// <returns>The registration result</returns>
        [HttpPost("register")]
        public async Task<IActionResult> Register([FromBody] CreateUserRequestDTO model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Fail_RequestInvalid,
                    Errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)
                });
            }

            var user = CreateUser();
            await _userStore.SetUserNameAsync(user, model.Email, CancellationToken.None);
            var emailStore = GetEmailStore();
            await emailStore.SetEmailAsync(user, model.Email, CancellationToken.None);

            var result = await _userManager.CreateAsync(user, model.Password);

            if (!result.Succeeded)
            {
                _logger.LogInformation("User registration failed: {Email}", model.Email);

                // Handle duplicate email error
                if (result.Errors.Any(e => e.Code == "DuplicateUserName"))
                {
                    return BadRequest(new RegisterUserResponseDTO
                    {
                        Status = RegisterUserResponseDTO.ResponseStatus.Fail_DuplicateEmail,
                    });
                }

                // Handle general Identity errors
                return BadRequest(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Fail_General,
                    Errors = result.Errors.Select(e => e.Description)
                });
            }

            _logger.LogInformation("User created a new account with a password.");

            // Send email confirmation link
            try
            {
                var userId = await _userManager.GetUserIdAsync(user);
                var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

                // NOTE: For security, it's recommended to configure a fixed base URL
                // from your application's settings rather than relying on the request host.
                var baseUrl = model.BaseUrl ?? $"{Request.Scheme}://{Request.Host.Value}";
                var callbackUrl = $"{baseUrl}/Account/ConfirmEmail?userId={userId}&code={code}";

                await _emailSender.SendConfirmationLinkAsync(user, model.Email, HtmlEncoder.Default.Encode(callbackUrl));
            }
            catch (Exception)
            {
                // Account created successfully but email sending failed.
                return Ok(new RegisterUserResponseDTO
                {
                    Status = RegisterUserResponseDTO.ResponseStatus.Success_EmailWarning,
                    Message = "The account was created, but the verification email sending failed."
                });
            }

            return Ok(new RegisterUserResponseDTO
            {
                Status = RegisterUserResponseDTO.ResponseStatus.Success_NeedConfirmation
            });
        }

        /// <summary>
        /// Resends the email confirmation link.
        /// </summary>
        /// <param name="model">Email confirmation request DTO</param>
        /// <returns>The result of the process</returns>
        [HttpPost("emailConfirm")]
        public async Task<IActionResult> ResendEmailConfirm([FromBody] RequestEmailConfirmDTO model)
        {
            if (!ModelState.IsValid)
            {
                // Always return a success response for security (to avoid user enumeration).
                return Ok(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                    Message = "The confirmation email has been sent successfully."
                });
            }

            try
            {
                var user = await _userManager.FindByEmailAsync(model.Email);

                // Even if the user doesn't exist or is already confirmed, return a success response for security.
                if (user == null || user.EmailConfirmed)
                {
                    return Ok(new ResponseEmailConfirmDTO
                    {
                        Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                        Message = "The confirmation email has been sent successfully."
                    });
                }

                // Generate and send the email confirmation link
                var userId = await _userManager.GetUserIdAsync(user);
                var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

                // NOTE: It is recommended to use a pre-configured base URL.
                var baseUrl = model.BaseUrl ?? $"{Request.Scheme}://{Request.Host.Value}";
                var callbackUrl = $"{baseUrl}/Account/ConfirmEmail?userId={userId}&code={code}";

                await _emailSender.SendConfirmationLinkAsync(user, model.Email, HtmlEncoder.Default.Encode(callbackUrl));

                return Ok(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Success,
                    Message = "The confirmation email has been sent successfully."
                });
            }
            catch (Exception)
            {
                // Mail server or other exception occurred.
                return BadRequest(new ResponseEmailConfirmDTO
                {
                    Status = ResponseEmailConfirmDTO.ResponseStatus.Fail,
                    Message = $"An error occurred while processing your request. (Server Error)"
                });
            }
        }

        /// <summary>
        /// Handles password reset requests.
        /// </summary>
        /// <param name="model">Password reset request DTO</param>
        /// <returns>The result of the process</returns>
        [HttpPost("resetPassword")]
        public async Task<IActionResult> ResetPassword([FromBody] ResetPasswordRequestDTO model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);
            if (user == null)
            {
                return BadRequest("User not found");
            }

            var resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
            var callbackUrl = $"{model.BaseUrl}/Account/ResetPassword?email={model.Email}&token={resetToken}";

            await _emailSender.SendPasswordResetLinkAsync(user, model.Email, callbackUrl);

            return Ok("Password reset link sent");
        }

        /// <summary>
        /// Handles user logout.
        /// </summary>
        /// <returns>The logout result</returns>
        [HttpPost("logout")]
        public async Task<IActionResult> Logout()
        {
            await _signInManager.SignOutAsync();
            return Ok("Logged out successfully");
        }

        /// <summary>
        /// Handles the generation of a JWT token.
        /// </summary>
        /// <param name="model">Login request DTO (email, password)</param>
        /// <returns>Token information</returns>
        [HttpPost("token")]
        public async Task<IActionResult> GenerateToken([FromBody] LoginUserRequestDTO model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);
            if (user == null || !await _userManager.CheckPasswordAsync(user, model.Password))
            {
                return Unauthorized("Invalid credentials");
            }

            var claims = new[]
            {
                new Claim(ClaimTypes.Name, user.UserName),
                new Claim(ClaimTypes.Email, user.Email)
            };

            // WARNING: Do not hard-code the key in production.
            // Move this to a secure configuration file (e.g., appsettings.json)
            // and use a strong, randomly generated key.
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("A_Very_Strong_And_Secret_Key_For_JWT_Auth"));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var token = new JwtSecurityToken(
                issuer: "yourdomain.com",
                audience: "yourdomain.com",
                claims: claims,
                expires: DateTime.Now.AddMinutes(30),
                signingCredentials: creds);

            return Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) });
        }

        #endregion

        #region External Authentication (OAuth)

        /// <summary>
        /// Initiates a challenge request to an external authentication provider (e.g., Google).
        /// </summary>
        /// <param name="provider">The name of the authentication provider (e.g., "Google")</param>
        /// <param name="returnUrl">The URL to redirect to after successful authentication</param>
        /// <returns>A challenge result to the external provider</returns>
        [HttpGet("Challenge/{provider}")]
        public IActionResult Challenge(string provider, string? returnUrl = null)
        {
            _logger.LogInformation("Starting {Provider} login", provider);

            if (string.IsNullOrWhiteSpace(provider))
            {
                return BadRequest(new { error = "Provider not specified." });
            }

            // Normalize and validate returnUrl
            returnUrl = NormalizeReturnUrl(returnUrl);

            // Set the callback URL
            var redirectUrl = Url.Action("Callback", "Auth", new { returnUrl }, Request.Scheme);

            // Configure authentication properties
            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);

            return Challenge(properties, provider);
        }

        /// <summary>
        /// Handles the callback from an external authentication provider.
        /// </summary>
        /// <param name="returnUrl">The URL to redirect to after successful authentication</param>
        /// <param name="remoteError">Error message from the external provider</param>
        /// <returns>An appropriate response based on the authentication result</returns>
        [HttpGet("externalLogin")]
        public async Task<IActionResult> Callback(string? returnUrl = null, string? remoteError = null)
        {
            try
            {
                returnUrl = NormalizeReturnUrl(returnUrl);

                if (!string.IsNullOrEmpty(remoteError))
                {
                    _logger.LogError("External provider error: {RemoteError}", remoteError);
                    return Redirect($"/login?error={Uri.EscapeDataString(remoteError)}");
                }

                var info = await _signInManager.GetExternalLoginInfoAsync();
                if (info == null)
                {
                    _logger.LogError("Could not retrieve external login info");
                    return Redirect("/login?error=external_login_failed");
                }

                // Attempt to sign in an existing user
                var result = await _signInManager.ExternalLoginSignInAsync(
                    info.LoginProvider,
                    info.ProviderKey,
                    isPersistent: false,
                    bypassTwoFactor: true);

                if (result.Succeeded)
                {
                    var user = await _userManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
                    _logger.LogInformation("User {Email} successfully logged in", user?.Email);
                    return LocalRedirect(returnUrl);
                }

                if (result.IsLockedOut)
                {
                    _logger.LogWarning("Attempt to log in with a locked-out account");
                    return Redirect("/login?error=locked_out");
                }

                // New user or linking an existing user
                return await HandleUserCreationOrLinking(info, returnUrl);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while processing external login");
                return Redirect("/login?error=server_error");
            }
        }

        #endregion

        #region Helper Methods

        /// <summary>
        /// Normalizes and validates the returnUrl.
        /// </summary>
        private string NormalizeReturnUrl(string? returnUrl)
        {
            if (string.IsNullOrWhiteSpace(returnUrl))
                return "/";

            if (Uri.TryCreate(returnUrl, UriKind.Absolute, out var uri))
                returnUrl = uri.PathAndQuery;

            return Url.IsLocalUrl(returnUrl) ? returnUrl : "/";
        }

        /// <summary>
        /// Handles new user creation or linking an existing user to an external login.
        /// </summary>
        private async Task<IActionResult> HandleUserCreationOrLinking(ExternalLoginInfo info, string returnUrl)
        {
            var email = info.Principal.FindFirstValue(ClaimTypes.Email);
            if (string.IsNullOrEmpty(email))
            {
                _logger.LogError("Missing email information from external provider {Provider}", info.LoginProvider);
                return Redirect("/login?error=email_required");
            }

            var existingUser = await _userManager.FindByEmailAsync(email);
            return existingUser != null
                ? await LinkExistingUser(existingUser, info, returnUrl)
                : await CreateNewUserAsync(info, returnUrl);
        }

        /// <summary>
        /// Links external login information to an existing user.
        /// </summary>
        private async Task<IActionResult> LinkExistingUser(ApplicationUser user, ExternalLoginInfo info, string returnUrl)
        {
            var addLoginResult = await _userManager.AddLoginAsync(user, info);
            if (addLoginResult.Succeeded)
            {
                _logger.LogInformation("Successfully linked {Provider} login to existing user {Email}", info.LoginProvider, user.Email);
                await _signInManager.SignInAsync(user, isPersistent: false, info.LoginProvider);
                return LocalRedirect(returnUrl);
            }

            _logger.LogError("Failed to link external login to existing user: {Errors}",
                string.Join(", ", addLoginResult.Errors.Select(e => e.Description)));
            return Redirect("/login?error=link_failed");
        }

        /// <summary>
        /// Creates a new user based on external login information.
        /// </summary>
        private async Task<IActionResult> CreateNewUserAsync(ExternalLoginInfo info, string returnUrl)
        {
            var email = info.Principal.FindFirstValue(ClaimTypes.Email);
            if (string.IsNullOrEmpty(email))
            {
                _logger.LogError("Missing email information from external provider");
                return BadRequest(new { error = "Email information was not provided." });
            }

            var userName = email.Split('@')[0];
            var user = new ApplicationUser
            {
                UserName = email,
                Email = email,
                NickName = userName,
                EmailConfirmed = true // Email is already confirmed via external provider
            };

            var createResult = await _userManager.CreateAsync(user);
            if (!createResult.Succeeded)
            {
                _logger.LogError("User creation failed: {Errors}",
                    string.Join(", ", createResult.Errors.Select(e => e.Description)));

                // Attempt to create an alternative user name on a naming conflict
                if (createResult.Errors.Any(e => e.Code == "DuplicateUserName"))
                {
                    user.UserName = $"{userName}_{Guid.NewGuid().ToString("N").Substring(0, 4)}";
                    createResult = await _userManager.CreateAsync(user);

                    if (!createResult.Succeeded)
                    {
                        return BadRequest(new
                        {
                            error = "Account creation failed",
                            details = createResult.Errors.Select(e => e.Description)
                        });
                    }
                }
                else
                {
                    return BadRequest(new
                    {
                        error = "Account creation failed",
                        details = createResult.Errors.Select(e => e.Description)
                    });
                }
            }

            // Link external login information
            var addLoginResult = await _userManager.AddLoginAsync(user, info);
            if (!addLoginResult.Succeeded)
            {
                _logger.LogError("Failed to add login information: {Errors}",
                    string.Join(", ", addLoginResult.Errors.Select(e => e.Description)));

                // Rollback: Delete the created user
                await _userManager.DeleteAsync(user);

                return BadRequest(new
                {
                    error = "Failed to link external login information",
                    details = addLoginResult.Errors.Select(e => e.Description)
                });
            }

            _logger.LogInformation("New user created and logged in successfully: {Email}", email);
            await _signInManager.SignInAsync(user, isPersistent: false, info.LoginProvider);

            return LocalRedirect(returnUrl);
        }

        private ApplicationUser CreateUser()
        {
            try
            {
                return Activator.CreateInstance<ApplicationUser>();
            }
            catch
            {
                throw new InvalidOperationException($"Can't create an instance of '{nameof(ApplicationUser)}'. " +
                    $"Ensure that '{nameof(ApplicationUser)}' is not an abstract class and has a parameterless constructor.");
            }
        }

        private IUserEmailStore<ApplicationUser> GetEmailStore()
        {
            if (!_userManager.SupportsUserEmail)
            {
                throw new NotSupportedException("The default UI requires a user store with email support.");
            }
            return (IUserEmailStore<ApplicationUser>)_userStore;
        }

        #endregion

        #region Profile Management

        /// <summary>
        /// Handles user profile updates.
        /// </summary>
        /// <param name="model">Update request DTO</param>
        /// <returns>The result of the process</returns>
        [HttpPut("updateProfile")]
        public async Task<IActionResult> UpdateProfile([FromBody] UpdateUserProfileDTO model)
        {
            var user = await _userManager.FindByIdAsync(model.Email);
            if (user == null)
            {
                return NotFound("User not found");
            }

            user.NickName = model.Nickname;
            user.PhoneNumber = model.PhoneNumber;

            var result = await _userManager.UpdateAsync(user);
            if (!result.Succeeded)
            {
                return BadRequest(result.Errors.Select(e => e.Description));
            }

            return Ok("Profile updated successfully");
        }

        /// <summary>
        /// Handles user deletion.
        /// </summary>
        /// <param name="userId">The ID of the user to delete</param>
        /// <returns>The result of the process</returns>
        [HttpDelete("deleteUser/{userId}")]
        public async Task<IActionResult> DeleteUser(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return NotFound("User not found");
            }

            var result = await _userManager.DeleteAsync(user);
            if (!result.Succeeded)
            {
                return BadRequest(result.Errors.Select(e => e.Description));
            }

            return Ok("User deleted successfully");
        }

        #endregion
    }
}

private void LoginWithGoogle()
{
    try
    {
        var returnUrl = "/";
        var googleLoginUrl = $"/api/auth/Challenge/Google?returnUrl={Uri.EscapeDataString(returnUrl)}";

        // Redirect in the current window instead of a popup
        // This is a placeholder for a client-side navigation method, e.g., in Blazor
        // Navigation.NavigateTo(googleLoginUrl, forceLoad: true);
    }
    catch (Exception ex)
    {
        // Error handling
        Console.WriteLine($"Google login error: {ex.Message}");
    }
}

The post ASP.NET Core Identity를 활용한 구글 로그인(OAuth) 전체 흐름 분석 appeared first on 어제와 내일의 나 그 사이의 이야기.

Ubuntu export 명령어

1⃣ 개요

export 명령어는 현재 셸 환경에 환경 변수를 등록하거나 수정하는 데 사용

등록된 변수는 현재 셸과 그 자식 프로세스에서 사용할 수 있음

2⃣ 기본 문법

export 변수명=값

또는

export 변수명

• 변수명=값 : 새 환경 변수를 만들거나 기존 변수 값을 변경
• 변수명 : 이미 선언된 변수를 환경 변수로 승격

3⃣ 특징

• 환경 변수는 프로세스 간 전달 가능 (부모 → 자식).
• export로 설정한 변수는 현재 세션에서만 유효.
• 영구적으로 유지하려면 ~/.bashrc 또는 ~/.bash_profile에 추가해야 함.

4⃣ 확인 방법

echo $변수명       # 변수 값 출력
printenv 변수명    # 환경 변수 확인
env                # 전체 환경 변수 목록

.NET에서의 사용 예시

1⃣ ASP.NET Core에서 환경 지정

export ASPNETCORE_ENVIRONMENT=Development
export ASPNETCORE_ENVIRONMENT=Staging
export ASPNETCORE_ENVIRONMENT=Production

export DOTNET_ENVIRONMENT=Development
export DOTNET_ENVIRONMENT=Staging // 실제 운영 환경(Production)과 거의 동일하지만, 사용자에게는 서비스되지 않는 사전 검증용 환경
export DOTNET_ENVIRONMENT=Production

dotnet run

• 예를 들어 Development로 설정하면, 개발 모드 환경 설정(appsettings.Development.json)을 자동으로 사용

2⃣ .NET에서 특정 포트로 실행

# 5005번 포트로 애플리케이션 실행
export ASPNETCORE_URLS="http://localhost:5005"

dotnet run

• ASPNETCORE_URLS 환경 변수를 이용해 실행 시 포트를 변경할 수 있음

3⃣ 영구 설정

# 1. .bashrc 파일에 환경 변수 설정 명령어를 추가
echo 'export DOTNET_ENVIRONMENT=Production' >> ~/.bashrc

# 2. 수정된 .bashrc 설정을 현재 터미널 세션에 바로 적용
source ~/.bashrc

# 3. 설정 확인
echo $DOTNET_ENVIRONMENT

The post Ubuntu export 명령어 (.NET) appeared first on 어제와 내일의 나 그 사이의 이야기.

ASP.NET Identity는 .NET 애플리케이션에서 사용자 인증과 권한 관리를 담당하는 시스템입니다.

이 시스템은 7개의 핵심 테이블로 구성되어 있으며, 각각은 특별한 역할을 수행합니다.

전체 구조 개요

 사용자 (AspNetUsers)
     다대다 관계
 역할 (AspNetRoles)
    
 권한/정보 (Claims)
 로그인 정보 (Logins, Tokens)

1. AspNetUsers – 사용자 기본 정보

역할: 회원가입한 사용자들의 기본 정보를 저장하는 메인 테이블

주요 필드 설명

보안 관련 필드들

SecurityStamp: 보안이 변경될 때마다 갱신되는 “도장”

• 비밀번호 변경, 이메일 변경 시 자동 갱신
• 이전 로그인 세션들을 무효화하는 역할

ConcurrencyStamp: 동시 수정 방지 “버전 번호”

• 여러 사용자가 같은 계정을 동시에 수정하는 것을 방지

실제 사용 예시

// 사용자 계정 잠금 확인
if (user.LockoutEnd.HasValue && user.LockoutEnd > DateTime.UtcNow)
{
    // 계정이 잠겨있음
    return "계정이 일시적으로 잠겨있습니다.";
}

// 로그인 실패 횟수 증가
user.AccessFailedCount++;
if (user.AccessFailedCount >= 5)
{
    user.LockoutEnd = DateTime.UtcNow.AddMinutes(30);
}

2. AspNetRoles – 역할 정의

역할: 사용자들을 그룹으로 분류하는 역할(Role) 정보 저장

주요 필드

일반적인 역할 예시

// 기본 역할들
var roles = new[]
{
    new IdentityRole { Name = "SuperAdmin", NormalizedName = "SUPERADMIN" },
    new IdentityRole { Name = "Admin", NormalizedName = "ADMIN" },
    new IdentityRole { Name = "Manager", NormalizedName = "MANAGER" },
    new IdentityRole { Name = "Employee", NormalizedName = "EMPLOYEE" },
    new IdentityRole { Name = "Customer", NormalizedName = "CUSTOMER" }
};

3. AspNetUserRoles – 사용자-역할 연결

역할: 어떤 사용자가 어떤 역할을 가지는지 매핑하는 중간 테이블

구조

관계 예시

사용자 "김철수" (UserId: user123)
├── Admin 역할 (RoleId: role-admin)
└── Manager 역할 (RoleId: role-manager)

사용자 "이영희" (UserId: user456)
└── Employee 역할 (RoleId: role-employee)

실제 사용법

// 사용자에게 역할 할당
await userManager.AddToRoleAsync(user, "Admin");

// 사용자의 모든 역할 조회
var userRoles = await userManager.GetRolesAsync(user);
// 결과: ["Admin", "Manager"]

// 특정 역할 확인
bool isAdmin = await userManager.IsInRoleAsync(user, "Admin");

4. Claims 시스템 – 세부 권한 관리

클레임(Claim)이란? 사용자나 역할에 대한 “주장” 또는 “속성”을 나타내는 이름-값 쌍입니다.

클레임 vs 역할 비교

AspNetRoleClaims – 역할별 클레임

역할: 특정 역할에 속한 모든 사용자가 공통으로 가지는 권한/속성

실제 예시:

// "Admin" 역할에 클레임 추가
var claims = new[]
{
    new Claim("Permission", "CanManageUsers"),
    new Claim("Permission", "CanDeletePosts"),
    new Claim("Permission", "CanViewReports"),
    new Claim("Department", "Management")
};

foreach (var claim in claims)
{
    await roleManager.AddClaimAsync(adminRole, claim);
}

AspNetUserClaims – 개인별 클레임

역할: 특정 사용자에게만 부여되는 개별적인 권한/속성

실제 예시:

// 특정 사용자에게만 베타 기능 접근 권한 부여
var betaClaim = new Claim("Feature", "BetaAccess");
await userManager.AddClaimAsync(user, betaClaim);

// VIP 고객 표시
var vipClaim = new Claim("CustomerLevel", "VIP");
await userManager.AddClaimAsync(user, vipClaim);

5. AspNetUserLogins – 외부 로그인 연동

역할: 구글, 페이스북 등 외부 서비스를 통한 로그인 정보 저장

구조

연동 과정 예시

1. 사용자가 "구글로 로그인" 클릭
2. 구글에서 인증 완료 후 사용자 정보 반환 (ProviderKey: google-12345)
3. AspNetUserLogins 테이블에서 해당 ProviderKey 검색
4. 기존 계정이 있으면 로그인, 없으면 새 계정 생성

실제 구현

// 외부 로그인 정보 추가
var loginInfo = new UserLoginInfo("Google", "google-12345", "Google");
await userManager.AddLoginAsync(user, loginInfo);

// 사용자의 모든 외부 로그인 조회
var logins = await userManager.GetLoginsAsync(user);
// 결과: [{ Provider: "Google", Key: "google-12345" }, ...]

6. AspNetUserTokens – 인증 토큰 관리

역할: 사용자별 각종 보안 토큰 저장 (리프레시 토큰, 인증 코드 등)

구조

토큰 유형별 예시

1. 리프레시 토큰

// 리프레시 토큰 저장
await userManager.SetAuthenticationTokenAsync(
    user, "MyApp", "RefreshToken", "abc123def456ghi789");

2. 이메일 인증 토큰

// 이메일 인증 토큰 생성 및 저장
var emailToken = await userManager.GenerateEmailConfirmationTokenAsync(user);
// 자동으로 AspNetUserTokens에 저장됨

3. 비밀번호 재설정 토큰

// 비밀번호 재설정 토큰 생성
var resetToken = await userManager.GeneratePasswordResetTokenAsync(user);

권한 검사 실제 활용법

1. 컨트롤러에서 역할 기반 권한 검사

[Authorize(Roles = "Admin,Manager")]
public class AdminController : Controller
{
    public IActionResult Dashboard()
    {
        return View();
    }
}

2. 클레임 기반 권한 검사

[Authorize(Policy = "CanManageUsers")]
public class UserManagementController : Controller
{
    public async Task<IActionResult> DeleteUser(string userId)
    {
        // 사용자 삭제 로직
        return Ok();
    }
}

// Startup.cs에서 정책 정의
services.AddAuthorization(options =>
{
    options.AddPolicy("CanManageUsers", policy =>
        policy.RequireClaim("Permission", "CanManageUsers"));
});

3. 코드에서 동적 권한 검사

public async Task<IActionResult> SomeAction()
{
    // 현재 사용자가 특정 클레임을 가지고 있는지 확인
    if (User.HasClaim("Permission", "CanDeletePosts"))
    {
        // 게시물 삭제 가능
    }
    
    // 역할 확인
    if (User.IsInRole("Admin"))
    {
        // 관리자 전용 기능
    }
    
    return View();
}

실무 시나리오 예시

회사 내부 시스템 권한 설계

1. 역할 구조

SuperAdmin (최고 관리자)
├── Admin (일반 관리자)
├── HRManager (인사 관리자)
├── ProjectManager (프로젝트 관리자)
├── Developer (개발자)
├── Designer (디자이너)
└── Intern (인턴)

2. 클레임 설계

// 부서별 클레임
ClaimType: "Department"
Values: "Engineering", "Design", "HR", "Marketing"

// 권한별 클레임
ClaimType: "Permission"
Values: "ViewSalary", "EditProject", "DeleteUser", "ViewReports"

// 레벨별 클레임
ClaimType: "Level"
Values: "Senior", "Junior", "Lead"

3. 실제 적용

// 사용자 "김개발"의 권한 설정
var developer = await userManager.FindByNameAsync("kim_developer");

// 역할 할당
await userManager.AddToRoleAsync(developer, "Developer");

// 개인 클레임 할당
await userManager.AddClaimAsync(developer, new Claim("Department", "Engineering"));
await userManager.AddClaimAsync(developer, new Claim("Level", "Senior"));
await userManager.AddClaimAsync(developer, new Claim("Permission", "ViewReports"));

4. 권한 검사

// 급여 정보는 HR 부서와 본인만 볼 수 있음
[Authorize]
public async Task<IActionResult> ViewSalary(string userId)
{
    var currentUser = await userManager.GetUserAsync(User);
    
    // 본인 정보이거나 HR 부서인 경우만 허용
    if (currentUser.Id == userId || 
        User.HasClaim("Department", "HR"))
    {
        return View();
    }
    
    return Forbid();
}

테이블 간 관계 요약

AspNetUsers (사용자)
    ├── AspNetUserRoles → AspNetRoles (역할)
    ├── AspNetUserClaims (개인 클레임)
    ├── AspNetUserLogins (외부 로그인)
    └── AspNetUserTokens (인증 토큰)

AspNetRoles (역할)
    └── AspNetRoleClaims (역할별 클레임)

핵심 포인트

1. 역할(Role)은 사용자를 그룹으로 분류하는 개념
2. 클레임(Claim)은 세부적인 권한과 속성을 정의하는 개념
3. 역할 클레임은 해당 역할의 모든 사용자에게 적용
4. 사용자 클레임은 특정 사용자에게만 적용
5. 외부 로그인으로 여러 인증 방식 통합 가능
6. 토큰으로 다양한 인증 시나리오 지원

이러한 구조를 통해 복잡한 권한 관리와 인증 시스템을 유연하고 안전하게 구현할 수 있습니다.

The post ASP.NET Identity 데이터베이스 appeared first on 어제와 내일의 나 그 사이의 이야기.

1. 개요

C# 애플리케이션이 소스 코드에서 실행 가능한 프로그램으로 변환되는 과정은 여러 단계로 이루어져 있습니다.

C# 컴파일러, 중간 언어(IL), 어셈블리(DLL, EXE), JIT 컴파일러 간의 관계와 전체 실행 흐름을 설명합니다.

2. 전체 실행 흐름

C# 소스 코드 → C# 컴파일러(Roslyn) → IL 코드 포함 DLL/EXE → CLR 로딩 → JIT 컴파일러 → 네이티브 머신 코드 → CPU 실행

3. C# 컴파일러 (로슬린 – Roslyn)

역할

• C# 소스 코드(.cs 파일)를 중간 언어(IL, Intermediate Language)로 변환

특징

• Microsoft의 오픈 소스 컴파일러 플랫폼
• csc.exe로 실행되거나 dotnet build 명령어 실행 시 자동 호출
• 어휘 분석, 구문 분석, 의미 분석, IL 생성의 단계적 작업 수행
• 주요 최적화는 JIT 컴파일 단계로 미루어짐

컴파일러 파이프라인 구성요소

• Syntax Tree API: 소스 코드의 구문적 구조 표현
• Semantic Model API: 코드의 의미론적 정보 제공
• Compilation API: 컴파일 과정 제어
• Workspace API: 솔루션, 프로젝트, 문서 등 작업 환경 관리

C# 코드 예시

public class Program 
{
    public static void Main() 
    {
        Console.WriteLine("Hello, World!");
    }
}

4. 중간 언어 (IL, Intermediate Language)

특징

• CPU 아키텍처에 독립적인 저수준 언어
• .dll 또는 .exe 파일 내에 포함됨
• 인간이 읽을 수 있는 형태(ILASM)로도 표현 가능
• CLR(공통 언어 런타임)이 이해하는 언어
• 스택 기반 명령어 집합으로 구성

주요 특성

• 스택 기반 명령어 집합: 주로 스택을 사용하여 연산 수행
• 객체 지향 지원: 클래스, 상속, 가상 메서드 등 지원
• 타입 안전성: 강력한 타입 시스템 유지
• 메타데이터 통합: 코드와 메타데이터가 밀접하게 연결

IL 코드 예시

// 위 C# 코드의 IL 표현 (간략화)
.method public hidebysig static void Main() cil managed {
  .entrypoint
  ldstr "Hello, World!"
  call void [System.Console]System.Console::WriteLine(string)
  ret
}

5. DLL과 EXE 파일 (어셈블리)

공통점

• 모두 PE(Portable Executable) 형식의 파일
• 메타데이터(형식 정보)와 IL 코드 포함
• .NET 어셈블리로서 버전 관리, 보안 정보 등 포함

차이점

어셈블리 구성요소

• 매니페스트: 어셈블리 ID, 버전, 문화권, 강력한 이름 등의 정보
• 타입 메타데이터: 클래스, 메서드, 프로퍼티 등의 정보
• IL 코드: 실행 가능한 중간 언어 코드
• 리소스: 이미지, 문자열 등 포함 가능

6. CLR(공통 언어 런타임)

역할

• .NET 애플리케이션의 실행 환경 제공
• 메모리 관리, 보안, 예외 처리 등 다양한 서비스 제공

주요 구성요소

• 클래스 로더: 필요한 타입을 메모리에 로드
• JIT 컴파일러: IL을 네이티브 코드로 변환
• 가비지 컬렉터: 자동 메모리 관리
• 보안 시스템: 코드 접근 보안(CAS) 등 제공
• 스레드 관리: 다중 스레드 실행 지원
• 예외 처리기: 예외 발생 및 처리 관리

7. JIT 컴파일러 (Just-In-Time)

역할

• IL 코드를 네이티브 머신 코드로 변환
• 실행 시점에 최적화 수행

작동 과정

1. 애플리케이션 실행 시 CLR 로드
2. 메서드 첫 호출 시 해당 IL 코드 JIT 컴파일
3. 컴파일된 네이티브 코드 캐싱 (재사용)
4. 실제 CPU에서 실행

최적화 기법

• 인라인 확장: 작은 메서드를 호출 위치에 직접 삽입
• 가상 메서드 최적화: 런타임 시 실제 타입 기반 최적화
• 루프 최적화: 루프 언롤링, 벡터화 등
• 불필요한 경계 검사 제거: 배열 접근 최적화
• 상수 폴딩: 컴파일 시점에 상수 표현식 계산
• 티어드 컴파일: 처음에는 빠르게 컴파일된 덜 최적화된 코드 실행, 후에 더 최적화된 버전으로 대체

8. 상세 실행 흐름

1. C# 소스 코드 작성
   • 개발자가 .cs 파일에 C# 코드 작성
2. C# 컴파일러(Roslyn) 처리
   • 어휘 분석(Lexical Analysis): 소스 코드를 토큰으로 분리
   • 구문 분석(Syntax Analysis): 토큰을 구문 트리로 구성
   • 의미 분석(Semantic Analysis): 타입 체킹, 타입 추론 등
   • IL 코드 생성: 컴파일된 중간 언어(IL) 생성
   • 메타데이터 생성: 타입 정보, 어셈블리 참조 등 생성
3. 어셈블리 생성
   • 컴파일된 IL 코드와 메타데이터가 PE(Portable Executable) 형식의 파일(.dll 또는 .exe)로 패키징
   • 어셈블리 매니페스트 포함: 버전, 문화권, 강력한 이름 등의 정보
4. 애플리케이션 실행
   • .exe 파일 실행시 CLR(공통 언어 런타임) 호스트(예: CoreCLR)가 로드됨
   • CLR은 메타데이터를 읽고 필요한 어셈블리 로드
5. JIT 컴파일
   • 메서드가 처음 호출될 때 JIT 컴파일러가 해당 메서드의 IL 코드를 네이티브 코드로 변환
   • 티어드 컴파일 적용 시 점진적 최적화
6. 실행
   • 생성된 네이티브 코드가 CPU에서 직접 실행
   • 가비지 컬렉션, 예외 처리 등 CLR 서비스가 실행 중 관리

9. 코드 변환 예시

C# 코드

public static int AddNumbers(int a, int b) {
    return a + b;
}

변환된 IL 코드

.method public static int32 AddNumbers(int32 a, int32 b) cil managed {
    .maxstack 2
    ldarg.0     // a를 스택에 로드
    ldarg.1     // b를 스택에 로드
    add         // 스택의 두 값을 더함
    ret         // 결과 반환
}

x86-64 네이티브 코드 (JIT 컴파일 후)

mov eax, ecx    ; 첫 번째 인수(a)를 eax로 이동
add eax, edx    ; 두 번째 인수(b)를 더함
ret             ; 결과(eax에 저장됨) 반환

10. 추가 정보

AOT(Ahead-of-Time) 컴파일

• JIT 대신 미리 네이티브 코드로 컴파일하는 방식
• 초기 시작 시간 단축 및 메모리 사용량 감소
• 모바일/임베디드 환경에 적합
• 일부 동적 기능 제한 (리플렉션 등)
• .NET 6 이상에서 Native AOT 지원

티어드 컴파일(Tiered Compilation)

• 처음에는 빠른 컴파일 우선으로 덜 최적화된 코드 생성
• 자주 사용되는 메서드는 백그라운드에서 더 많은 최적화 적용
• 시작 시간과 장기 실행 성능 사이의 균형 제공

11. 결론

.NET의 컴파일 및 실행 모델은 플랫폼 독립성과 성능 사이의 균형을 효과적으로 맞추고 있습니다.

C# 소스 코드가 Roslyn 컴파일러를 통해 IL로 변환되고, 이후 JIT 컴파일러에 의해 필요할 때 네이티브 코드로 변환되는 과정은 다양한 플랫폼에서의 실행을 가능하게 하면서도 최적화된 성능을 제공합니다.

최근 버전의 .NET에서는 AOT 컴파일, 티어드 컴파일 등 더 다양한 최적화 기법을 도입하여 성능을 더욱 향상시키고 있으며, 이는 클라우드 네이티브 애플리케이션과 마이크로서비스 아키텍처에서 특히 중요한 역할을 합니다.

The post .NET / C# Compiler, IL, DLL, EXE, JIT appeared first on 어제와 내일의 나 그 사이의 이야기.

Serialization (직렬화) 개요

Serialization이란 객체 데이터를 바이트 스트림으로 변환하여 저장하거나 전송할 수 있도록 하는 과정

주 목적은 필요할 때 다시 개체로 만들 수 있도록 개체의 상태를 저장하는 것

반대로 Deserialization은 저장된 바이트 데이터를 다시 객체로 변환하는 과정입니다.

JSON, XML, YAML

일반적으로 많이 사용하는 데이터 직렬화 포맷들

1⃣ JSON (JavaScript Object Notation)

특징

가벼운 텍스트 기반 포맷
사람이 읽고 쓰기 쉬우며, 기계가 빠르게 처리 가능
대부분의 프로그래밍 언어에서 지원 (C#, Python, JavaScript 등)
키-값 쌍의 구조 (Dictionary, Object와 유사)

예제

{
  "name": "John",
  "age": 30,
  "skills": ["C#", "Unity", "Python"],
  "isDeveloper": true
}

장점

가볍고 속도가 빠름
대부분의 언어에서 지원
API 및 데이터 전송에 적합 (REST API, WebSockets 등)

단점

주석 지원이 안됨
XML이나 YAML보다 덜 유연함

2⃣ XML (eXtensible Markup Language)

특징

데이터 구조를 계층적으로 표현 (HTML과 유사)
사람이 읽을 수 있지만, JSON보다 길이가 김
다양한 도메인에서 사용 (문서 저장, 설정 파일, 웹 서비스 등)
<태그>를 이용한 구조화된 데이터 표현

예제

<Person>
    <Name>John</Name>
    <Age>30</Age>
    <Skills>
        <Skill>C#</Skill>
        <Skill>Unity</Skill>
        <Skill>Python</Skill>
    </Skills>
    <IsDeveloper>true</IsDeveloper>
</Person>

장점

데이터 구조가 명확함
주석 사용 가능 (<!– 주석 –>)
다양한 데이터 타입을 표현하기 적합

단점

JSON보다 크기가 크고, 가독성이 떨어짐
파싱 속도가 느림

3⃣ YAML (YAML Ain’t Markup Language)

특징

JSON과 유사하지만 더 간결한 문법을 가짐
들여쓰기를 이용한 계층 구조 (Python과 유사)
설정 파일에서 많이 사용 (Docker, Kubernetes, Unity Config 등)

예제

name: John
age: 30
skills:
  - C#
  - Unity
  - Python
isDeveloper: true

장점

사람이 읽기 쉬운 직관적인 문법
JSON보다 간결하여 가독성이 좋음
주석 (#) 사용 가능

단점

들여쓰기 실수로 인한 오류 발생 가능
파싱 속도가 JSON보다 느림

비교 정리

Unity에서는 JSON (JsonUtility, Newtonsoft.Json)이 가장 많이 사용되며, YAML은 Unity의 설정 파일 (.yml)에서 많이 활용됩니다.

형식	문법	가독성	속도	사용 사례
JSON	{ "key": "value" }	좋음	빠름	API, 데이터 저장
XML	<tag>value</tag>	중간	느림	문서 저장, 설정 파일
YAML	key: value (들여쓰기)	매우 좋음	중간	설정 파일, DevOps

Unity에서의 스크립트 직렬화 (Serialization in Unity)

1⃣ Unity에서 직렬화가 중요한 이유

Unity는 Inspector 창에서 데이터를 유지하거나 저장 시스템(예: PlayerPrefs, JSON, Binary 파일 등)에 데이터를 저장하기 위해 직렬화를 활용합니다.

씬(Scene) 저장 및 로드: Inspector에 입력한 값이 유지됨
ScriptableObject: 게임 데이터 관리
Save/Load 시스템: JSON 또는 Binary 직렬화를 활용하여 파일 저장

2⃣ Unity에서 직렬화 가능한 타입

https://docs.unity3d.com/6000.0/Documentation/Manual/script-serialization-rules.html

Unity는 특정 데이터 타입만 직렬화할 수 있도록 제한하고 있습니다.

직렬화 가능한 타입 (Serializable)

기본 데이터 타입: int, float, bool, string 등
Unity 기본 타입: 배열 & 리스트: int[], List<float> 등 (단, public 또는 [SerializeField] 필요)
사용자 정의 클래스 ([System.Serializable] 필요)
ScriptableObject

직렬화 불가능한 타입 (Non-Serializable)

딕셔너리(Dictionary)
다차원 배열 (int[,])
속성(Property) (getter/setter)
Static 변수 (static)
추상 클래스 & 인터페이스
델리게이트(Delegate), 이벤트(Event)

3⃣ Unity 직렬화 적용 방법

[SerializeField]

private 변수도 Inspector에서 보이도록 만들고, 직렬화 가능하게 합니다.

using UnityEngine;

public class Player : MonoBehaviour
{
    [SerializeField] private int health = 100;  // 직렬화됨 (Inspector에서 수정 가능)
    private int score = 0;  // 직렬화되지 않음 (Inspector에서 보이지 않음)
}

[SerializeField]를 사용하면 private 변수도 직렬화됨
하지만 static, const, readonly 변수는 직렬화되지 않음

[System.Serializable]

사용자 정의 클래스를 직렬화하려면 [System.Serializable]을 붙여야 합니다.

using UnityEngine;

[System.Serializable]  
public class Weapon
{
    public string name;
    public int damage;
}

public class Player : MonoBehaviour
{
    public Weapon myWeapon;  // Weapon 클래스가 직렬화되므로 Inspector에서 수정 가능
}

클래스를 System.Serializable로 만들면 Unity Inspector에서 확인 가능
하지만 Dictionary, Properties, Static 변수 등은 여전히 직렬화되지 않음

ScriptableObject

게임 데이터를 저장 및 관리하는 특수한 직렬화 객체

using UnityEngine;

[CreateAssetMenu(fileName = "New Weapon", menuName = "Weapon")]
public class WeaponData : ScriptableObject
{
    public string weaponName;
    public int damage;
}

씬(Scene)과 독립적으로 데이터 관리 가능
메모리 효율적 관리 가능 (오브젝트 풀링, 설정 저장 등)
런타임에서 수정된 값은 저장되지 않음 (Play 모드가 끝나면 초기화됨)

4⃣ Unity 직렬화와 JSON 활용

Unity에서 JSON 직렬화를 활용하면 데이터 저장 & 로드가 가능해집니다.

JsonUtility (빠르지만 제한적)

using UnityEngine;

[System.Serializable]
public class PlayerData
{
    public string name;
    public int level;
}

public class SaveLoadSystem : MonoBehaviour
{
    void Start()
    {
        PlayerData player = new PlayerData { name = "John", level = 10 };
        string json = JsonUtility.ToJson(player);
        Debug.Log(json);  // {"name":"John","level":10}

        PlayerData loadedPlayer = JsonUtility.FromJson<PlayerData>(json);
        Debug.Log(loadedPlayer.name);  // John
    }
}

빠름 & Unity 기본 지원
Dictionary, List<T> 같은 복잡한 자료형 지원 X

Newtonsoft.Json (더 강력한 JSON 직렬화)

Newtonsoft.Json 라이브러리를 사용하면 Dictionary, List, Interface 등도 직렬화 가능

using UnityEngine;
using Newtonsoft.Json;
using System.Collections.Generic;

public class PlayerData
{
    public string name;
    public int level;
    public Dictionary<string, int> inventory = new Dictionary<string, int>();
}

public class SaveLoadSystem : MonoBehaviour
{
    void Start()
    {
        PlayerData player = new PlayerData { name = "John", level = 10 };
        player.inventory.Add("Sword", 1);
        player.inventory.Add("Potion", 5);

        string json = JsonConvert.SerializeObject(player, Formatting.Indented);
        Debug.Log(json);

        PlayerData loadedPlayer = JsonConvert.DeserializeObject<PlayerData>(json);
        Debug.Log(loadedPlayer.inventory["Sword"]);  // 1
    }
}

Dictionary, List<T> 등 복잡한 자료형 지원
JsonUtility보다 속도가 느림
추가 라이브러리 설치 필요 (Newtonsoft.Json.dll)

The post Unity Serialization (직렬화) appeared first on 어제와 내일의 나 그 사이의 이야기.

EntityQuery 정리

ECS(Entity Component System)에서 특정 조건을 만족하는 Entity들을 효율적으로 검색하는 도구

Entity가 가진 컴포넌트 조합을 기준으로 검색하며, 이를 통해 메모리 캐시 효율을 극대화

1. EntityQuery의 기본 개념

• Entity 필터링: 특정한 컴포넌트를 포함하거나 제외하는 기준을 정할 수 있다.
• Chunk 단위 검색: EntityQuery는 Entity 개별 조회가 아닌 Chunk 단위(Archetype Chunk)로 데이터를 가져옴
• 즉시 검색 or Job 시스템과 병렬 처리 가능

– 특정 컴포넌트를 가진 Entity 찾기

public partial struct FindEntitiesSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        // PositionComponent와 VelocityComponent를 가진 Entity 찾기
        EntityQuery query = SystemAPI.QueryBuilder()
            .WithAll<PositionComponent, VelocityComponent>()
            .Build();

        foreach (var (position, velocity) in SystemAPI.Query<RefRW<PositionComponent>, RefRO<VelocityComponent>>())
        {
            position.ValueRW.Value += velocity.ValueRO.Value * SystemAPI.Time.DeltaTime;
        }
    }
}

• WithAll() → 모든 엔티티 중 PositionComponent와 VelocityComponent를 가진 것만 검색
• RefRW → 읽기/쓰기 가능
• RefRO → 읽기 전용

2. EntityQuery의 주요 조건

– 특정 조건의 엔티티 찾기

EntityQuery query = SystemAPI.QueryBuilder()
    .WithAll<PositionComponent>()   // PositionComponent가 있어야 함
    .WithAny<VelocityComponent, AccelerationComponent>()  // 둘 중 하나만 있으면 됨
    .WithNone<DestroyedTag>()        // DestroyedTag가 있으면 제외
    .Build();

• WithAll() → 반드시 포함
• WithAny() → 하나라도 포함
• WithNone() → 포함하면 안 됨

3. EntityQuery를 사용한 데이터 접근 방법

(1) SystemAPI.Query() 사용

• EntityQuery를 생성하고 foreach 루프에서 엔티티 데이터를 순회 가능

foreach (var (position, velocity) in SystemAPI.Query<RefRW<PositionComponent>, RefRO<VelocityComponent>>())
{
    position.ValueRW.Value += velocity.ValueRO.Value * SystemAPI.Time.DeltaTime;
}

(2) ToEntityArray()로 Entity 리스트 가져오기

• ToEntityArray()를 사용하면 해당 EntityQuery에 해당하는 Entity 리스트를 가져옴

var entities = query.ToEntityArray(Allocator.Temp);
foreach (var entity in entities)
{
    Debug.Log($"찾은 Entity: {entity}");
}
entities.Dispose();

• ToEntityArray(Allocator.Temp) → NativeArray로 Entity를 가져옴
• Dispose() 필수! 메모리 해제 안 하면 메모리 누수 발생

(3) ToComponentDataArray()로 특정 컴포넌트 리스트 가져오기

• 특정 컴포넌트의 값만 가져올 수도 있음.

var positions = query.ToComponentDataArray<PositionComponent>(Allocator.Temp);
foreach (var position in positions)
{
    Debug.Log($"Position: {position.Value}");
}
positions.Dispose();

• 데이터만 필요한 경우 성능 최적화 가능

4. IJobChunk과 함께 사용하기

• IJobChunk를 사용하면 EntityQuery를 멀티스레드로 병렬 처리 가능
• ArchetypeChunk을 사용하여 Chunk 단위 데이터 접근 가능

[BurstCompile]
public struct MoveJob : IJobChunk
{
    public ComponentTypeHandle<PositionComponent> PositionHandle;
    [ReadOnly] public ComponentTypeHandle<VelocityComponent> VelocityHandle;
    public float DeltaTime;

    public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
    {
        var positions = chunk.GetNativeArray(PositionHandle);
        var velocities = chunk.GetNativeArray(VelocityHandle);

        for (int i = 0; i < chunk.Count; i++)
        {
            positions[i] = new PositionComponent
            {
                Value = positions[i].Value + velocities[i].Value * DeltaTime
            };
        }
    }
}

public partial struct MoveSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var query = SystemAPI.QueryBuilder()
            .WithAll<PositionComponent, VelocityComponent>()
            .Build();

        var positionHandle = SystemAPI.GetComponentTypeHandle<PositionComponent>();
        var velocityHandle = SystemAPI.GetComponentTypeHandle<VelocityComponent>(isReadOnly: true);

        var job = new MoveJob
        {
            PositionHandle = positionHandle,
            VelocityHandle = velocityHandle,
            DeltaTime = SystemAPI.Time.DeltaTime
        };
        // query를 기반으로 Schedule()을 호출
        state.Dependency = job.Schedule(query, state.Dependency);
    }
}

• GetComponentTypeHandle<T>() 사용 → 컴포넌트 데이터를 가져올 때 캐시 최적화
  GetComponentTypeHandle<T>()은 ECS(Worlds)의 청크 단위 데이터 접근을 최적화하기 위한 API
• IJobChunk으로 멀티스레드 병렬 처리 가능

job.Schedule(query, state.Dependency)의 실행 과정

query를 사용하여 IJobChunk가 처리할 청크들을 찾음

• query는 PositionComponent와 VelocityComponent를 포함하는 엔티티들의 청크 목록을 가져옴.
• IJobChunk는 이 청크 목록을 기반으로 실행됨.

job.Schedule()을 호출하여 MoveJob을 실행

• query에서 반환된 청크를 MoveJob에서 병렬적으로 처리.
• 내부적으로 각 청크별로 MoveJob.Execute()가 실행됨.

state.Dependency를 업데이트하여 잡 실행을 관리

• state.Dependency는 현재 시스템의 의존성 체인을 관리.
• 이전 프레임에서 실행된 다른 잡들과의 의존 관계를 고려하여 동기화함.
• 병렬 처리를 안전하게 실행하기 위해 필요함.

(Q) ComponentTypeHandle을 사용하여 NativeArray를 생성하는 것과 미리 NativeArray를 넘겨주는 것의 차이점

(1) ComponentTypeHandle<T>을 사용하는 이유

GetComponentTypeHandle<T>()을 사용하여 IJobChunk 내부에서 NativeArray를 가져오는 이유는 Chunk 단위 접근 최적화 때문이다.

• ComponentTypeHandle<T>을 사용하면 각 Chunk에 맞는 NativeArray를 개별적으로 가져올 수 있음
• 만약 NativeArray를 미리 만들어서 넘겨준다면, Chunk별로 나눠진 데이터가 하나의 배열에 병합되어야 하므로 메모리 효율이 떨어지고 캐시 활용도가 낮아짐

(2) ComponentTypeHandle<T>과 NativeArray<T> 차이점 비교

(3) ComponentTypeHandle<T> 방식

1> SystemAPI.GetComponentTypeHandle<T>() 실행

var positionHandle = SystemAPI.GetComponentTypeHandle<PositionComponent>();
var velocityHandle = SystemAPI.GetComponentTypeHandle<VelocityComponent>(isReadOnly: true);

• ComponentTypeHandle<T>을 가져옴
• Chunk별로 데이터가 분산되어 있기 때문에 NativeArray<T>로 직접 변환하지 않음

2> MoveJob.Schedule() 실행

var job = new MoveJob
{
    PositionHandle = positionHandle,
    VelocityHandle = velocityHandle,
    DeltaTime = SystemAPI.Time.DeltaTime
};

state.Dependency = job.Schedule(query, state.Dependency);

• MoveJob을 스케줄할 때 ComponentTypeHandle<T>을 넘김

3> MoveJob.Execute() 내부에서 GetNativeArray() 실행

var positions = chunk.GetNativeArray(PositionHandle);
var velocities = chunk.GetNativeArray(VelocityHandle);

• 각 Chunk에서 NativeArray<T>를 가져와서 사용함.
• 이렇게 하면 각 Chunk가 독립적으로 자신의 데이터에 접근할 수 있으며, 캐시 최적화 및 멀티스레딩 효율 증가

(4) NativeArray Job 방식

만약 NativeArray<T>를 미리 만들어서 Job에 넘기면, 멀티스레딩 최적화가 어렵고 성능 저하 가능성 증가.

전체 데이터를 하나의 NativeArray로 병합하는 과정이 필요, Chunk별 데이터 레이아웃이 깨질 수 있음 → CPU 캐시 효율 저하.

NativeArray<PositionComponent> positions = new NativeArray<PositionComponent>(entityCount, Allocator.TempJob);
NativeArray<VelocityComponent> velocities = new NativeArray<VelocityComponent>(entityCount, Allocator.TempJob);

// Job에 NativeArray를 직접 넘김
var job = new MoveJob
{
    Positions = positions,
    Velocities = velocities,
    DeltaTime = SystemAPI.Time.DeltaTime
};

state.Dependency = job.Schedule(state.Dependency);

이 경우, positions와 velocities를 Chunk별로 나누지 않고 전체 데이터를 하나의 배열로 만듦.

Chunk별 데이터가 섞일 가능성이 높아져 캐시 미스(Cache Miss)가 증가할 수 있음

5. EntityQuery의 추가 기능

(1) CalculateEntityCount()로 개수 확인

int entityCount = query.CalculateEntityCount();
Debug.Log($"현재 쿼리 결과 개수: {entityCount}");

(2) SetChangedVersionFilter()로 변경된 컴포넌트만 검색

query.SetChangedVersionFilter<PositionComponent>();

최근 변경된 PositionComponent를 가진 엔티티만 검색

(3) Enable/Disable로 쿼리 활성화/비활성화

query.SetEnabled(false);  // 쿼리 비활성화
query.SetEnabled(true);   // 다시 활성화

쿼리를 특정 조건에서만 사용하고 싶을 때 활용

The post ECS – EntityQuery 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

using System;
using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics.GraphicsIntegration;
using Unity.Rendering;
using Unity.Transforms;
using UnityEngine;
using static Unity.Physics.Extensions.PhysicsSamplesExtensions;

namespace Unity.Physics.Extensions
{
    public class MouseHover : IComponentData
    {
        public bool IgnoreTriggers;
        public bool IgnoreStatic;
        public Entity PreviousEntity;
        public Entity CurrentEntity;
        public Entity HoverEntity;
        public MaterialMeshInfo OriginalMeshInfo;
        public RenderMeshArray OriginalRenderMeshes;
    }

    [DisallowMultipleComponent]
    public class MouseHoverAuthoring : MonoBehaviour
    {
        public GameObject HoverPrefab;
        public bool IgnoreTriggers = true;
        public bool IgnoreStatic = true;

        // Note: override OnEnable to be able to disable the component in the editor
        protected void OnEnable() {}
    }

    class MouseHoverBaker : Baker<MouseHoverAuthoring>
    {
        public override void Bake(MouseHoverAuthoring authoring)
        {
            var entity = GetEntity(TransformUsageFlags.None);
            AddComponentObject(entity, new MouseHover()
            {
                PreviousEntity = Entity.Null,
                CurrentEntity = Entity.Null,
                IgnoreTriggers = authoring.IgnoreTriggers,
                IgnoreStatic = authoring.IgnoreStatic,
                HoverEntity = GetEntity(authoring.HoverPrefab, TransformUsageFlags.Dynamic),
            });
        }
    }

    // Applies any mouse spring as a change in velocity on the entity's motion component
    // Limitations: works only if the physics objects in the scene come from the same subscene as MouseHoverAuthoring
    // Will be fixable if there is a Unity.Rendering API that lets you get the UnityEngine.Mesh that an entity is using for renderin.

    [UpdateInGroup(typeof(InitializationSystemGroup))]
    public partial class MouseHoverSystem : SystemBase
    {
        [BurstCompile]
        public struct WorldRaycastJob : IJob
        {
            public RaycastInput RayInput;
            [ReadOnly] public CollisionWorld CollisionWorld;
            [ReadOnly] public bool IgnoreTriggers;
            [ReadOnly] public bool IgnoreStatic;

            public NativeReference<RaycastHit> RaycastHitRef;

            public void Execute()
            {
                var mousePickCollector = new MousePickCollector(CollisionWorld.NumDynamicBodies)
                {
                    IgnoreTriggers = IgnoreTriggers,
                    IgnoreStatic = IgnoreStatic
                };

                if (CollisionWorld.CastRay(RayInput, ref mousePickCollector))
                {
                    RaycastHitRef.Value = mousePickCollector.Hit;
                }
            }
        }

        protected override void OnCreate()
        {
            base.OnCreate();
            RequireForUpdate<MouseHover>();
        }

        // Find the Entity holding the Graphical representation of a Physics Shape.
        // It may be that the Physics and Graphics representation are on the same Entity.
        public Entity FindGraphicsEntityFromPhysics(Entity bodyEntity) => FindGraphicsEntityFromPhysics(bodyEntity, ColliderKey.Empty);
        public Entity FindGraphicsEntityFromPhysics(Entity bodyEntity, ColliderKey leafColliderKey)
        {
            if (bodyEntity.Equals(Entity.Null))
            {
                // No Physics so no Graphics
                return Entity.Null;
            }

            // Set the Graphics Entity to the supplied Physics Entity
            var renderEntity = bodyEntity;

            // Check if we have hit a leaf node
            if (!leafColliderKey.Equals(ColliderKey.Empty))
            {
                // Get the Physics Collider
                var rootCollider = EntityManager.GetComponentData<PhysicsCollider>(bodyEntity).Value;

                // If we hit a CompoundCollider we need to find the original Entity associated
                // the actual leaf Collider that was hit.
                if (rootCollider.Value.Type == ColliderType.Compound)
                {
                    #region Find a Leaf Entity and ColliderKey
                    var leafEntity = Entity.Null;
                    unsafe
                    {
                        var rootColliderPtr = rootCollider.AsPtr();

                        // Get the leaf Collider and check if we hit was a PolygonCollider (i.e. a Triangle or a Quad)
                        rootColliderPtr->GetLeaf(leafColliderKey, out var childCollider);
                        leafEntity = childCollider.Entity;

                        // PolygonColliders are likely to not have an original Entity associated with them
                        // So if we have a Polygon and it has no Entity then we really need to check for
                        // the higher level Mesh or Terrain Collider instead.
                        var childColliderType = childCollider.Collider->Type;
                        var childColliderIsPolygon = childColliderType == ColliderType.Triangle || childColliderType == ColliderType.Quad;
                        if (childColliderIsPolygon && childCollider.Entity.Equals(Entity.Null))
                        {
                            // Get the ColliderKey of the Polygon's parent
                            if (TryGetParentColliderKey(rootColliderPtr, leafColliderKey, out leafColliderKey))
                            {
                                // Get the Mesh or Terrain Collider of the Polygon
                                TryGetChildInHierarchy(rootColliderPtr, leafColliderKey, out childCollider);
                                leafEntity = childCollider.Entity;
                            }
                        }
                    }
                    #endregion

                    // The Entities recorded in the leaves of a CompoundCollider may have been correct
                    // at the time of conversion. However, if the Collider blob is shared, or came up
                    // through a sub scene, we cannot assume that the baked Entities in the
                    // CompoundCollider are still valid.

                    // On conversion Entities using a CompoundCollider have an extra dynamic buffer added
                    // which holds a list of Entity/ColliderKey pairs. This buffer should be patched up
                    // automatically and be valid with each instance, at least until you start messing
                    // with the Entity hierarchy yourself e.g. by deleting Entities.

                    #region Check the Leaf Entity is valid
                    // If the leafEntity was never assigned in the first place
                    // there is no point in looking up any Buffers.
                    if (!leafEntity.Equals(Entity.Null))
                    {
                        // Check for an Key/Entity pair buffer first.
                        // This should exist if the Physics conversion pipeline was invoked.
                        var colliderKeyEntityPairBuffers = GetBufferLookup<PhysicsColliderKeyEntityPair>(true);
                        if (colliderKeyEntityPairBuffers.HasBuffer(bodyEntity))
                        {
                            var colliderKeyEntityBuffer = colliderKeyEntityPairBuffers[bodyEntity];
                            for (int i = 0; i < colliderKeyEntityBuffer.Length; i++)
                            {
                                var bufferColliderKey = colliderKeyEntityBuffer[i].Key;
                                if (leafColliderKey.Equals(bufferColliderKey))
                                {
                                    renderEntity = colliderKeyEntityBuffer[i].Entity;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            // We haven't found a Key/Entity pair buffer so the compound collider
                            // may have been created in code.

                            // We'll assume the Entity in the CompoundCollider is valid
                            renderEntity = leafEntity;

                            // If this CompoundCollider was instanced from a prefab then the entities
                            // in the compound children would actually reference the original prefab hierarchy.
                            var rootEntityFromLeaf = leafEntity;
                            while (SystemAPI.HasComponent<Parent>(rootEntityFromLeaf))
                            {
                                rootEntityFromLeaf = SystemAPI.GetComponent<Parent>(rootEntityFromLeaf).Value;
                            }

                            // If the root Entity found from the leaf does not match the body Entity
                            // then we have hit an instance using the same CompoundCollider.
                            // This means we can try and remap the leaf Entity to the new hierarchy.
                            if (!rootEntityFromLeaf.Equals(bodyEntity))
                            {
                                // This assumes there is a LinkedEntityGroup Buffer on original and instance Entity.
                                // No doubt there is a more optimal way of doing this remap with more specific
                                // knowledge of the final application.
                                var linkedEntityGroupBuffers = GetBufferLookup<LinkedEntityGroup>(true);

                                // Only remap if the buffers exist, have been created and are of equal length.
                                bool hasBufferRootEntity = linkedEntityGroupBuffers.HasBuffer(rootEntityFromLeaf);
                                bool hasBufferBodyEntity = linkedEntityGroupBuffers.HasBuffer(bodyEntity);
                                if (hasBufferRootEntity && hasBufferBodyEntity)
                                {
                                    var prefabEntityGroupBuffer = linkedEntityGroupBuffers[rootEntityFromLeaf];
                                    var instanceEntityGroupBuffer = linkedEntityGroupBuffers[bodyEntity];

                                    if (prefabEntityGroupBuffer.IsCreated && instanceEntityGroupBuffer.IsCreated
                                        && (prefabEntityGroupBuffer.Length == instanceEntityGroupBuffer.Length))
                                    {
                                        var prefabEntityGroup = prefabEntityGroupBuffer.AsNativeArray();
                                        var instanceEntityGroup = instanceEntityGroupBuffer.AsNativeArray();

                                        for (int i = 0; i < prefabEntityGroup.Length; i++)
                                        {
                                            // If we've found the renderEntity index in the prefab hierarchy,
                                            // set the renderEntity to the equivalent Entity in the instance
                                            if (prefabEntityGroup[i].Value.Equals(renderEntity))
                                            {
                                                renderEntity = instanceEntityGroup[i].Value;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }
            }

            // Finally check to see if we have a graphics redirection on the shape Entity.
            if (SystemAPI.HasComponent<PhysicsRenderEntity>(renderEntity))
            {
                renderEntity = SystemAPI.GetComponent<PhysicsRenderEntity>(renderEntity).Entity;
            }

            // If no render info is found on the located render entity, we try to find any child which has render info
            if (renderEntity != Entity.Null && !EntityManager.HasComponent<MaterialMeshInfo>(renderEntity))
            {
                // No render information on this entity. Try to find the actual render entity in the hierarchy.
                if (EntityManager.HasBuffer<Child>(renderEntity))
                {
                    var children = EntityManager.GetBuffer<Child>(renderEntity);
                    foreach (var childElement in children)
                    {
                        // find the first child with render info
                        if (EntityManager.HasComponent<MaterialMeshInfo>(childElement.Value))
                        {
                            renderEntity = childElement.Value;
                        }
                    }
                }
            }

            return renderEntity;
        }

        protected override void OnUpdate()
        {
            var collisionWorld = SystemAPI.GetSingleton<PhysicsWorldSingleton>().CollisionWorld;
            Vector2 mousePosition = Input.mousePosition;
            UnityEngine.Ray unityRay = Camera.main.ScreenPointToRay(mousePosition);
            var rayInput = new RaycastInput
            {
                Start = unityRay.origin,
                End = unityRay.origin + unityRay.direction * MousePickSystem.k_MaxDistance,
                Filter = CollisionFilter.Default,
            };

            var mouseHover = SystemAPI.ManagedAPI.GetSingleton<MouseHover>();

            RaycastHit hit;
            using (var raycastHitRef = new NativeReference<RaycastHit>(Allocator.TempJob))
            {
                var rcj = new WorldRaycastJob()
                {
                    CollisionWorld = collisionWorld,
                    RayInput = rayInput,
                    IgnoreTriggers = mouseHover.IgnoreTriggers,
                    IgnoreStatic = mouseHover.IgnoreStatic,
                    RaycastHitRef = raycastHitRef
                };
                rcj.Run();
                hit = raycastHitRef.Value;
            }

            var graphicsEntity = FindGraphicsEntityFromPhysics(hit.Entity, hit.ColliderKey);

            // If still hovering over the same entity then do nothing.
            if (mouseHover.CurrentEntity.Equals(graphicsEntity)) return;

            mouseHover.PreviousEntity = mouseHover.CurrentEntity;
            mouseHover.CurrentEntity = graphicsEntity;

            bool hasPreviousEntity = !mouseHover.PreviousEntity.Equals(Entity.Null);
            bool hasCurrentEntity = !mouseHover.CurrentEntity.Equals(Entity.Null);

            if (hasPreviousEntity && EntityManager.HasComponent<MaterialMeshInfo>(mouseHover.PreviousEntity))
            {
                // restore render info to original in the last entity we were hovering over
                EntityManager.SetComponentData(mouseHover.PreviousEntity, mouseHover.OriginalMeshInfo);
                EntityManager.SetSharedComponentManaged(mouseHover.PreviousEntity, mouseHover.OriginalRenderMeshes);
            }

            if (hasCurrentEntity && EntityManager.HasComponent<MaterialMeshInfo>(mouseHover.CurrentEntity) && EntityManager.HasComponent<RenderMeshArray>(mouseHover.CurrentEntity))
            {
                mouseHover.PreviousEntity = mouseHover.CurrentEntity;
                mouseHover.CurrentEntity = graphicsEntity;
                mouseHover.OriginalMeshInfo = EntityManager.GetComponentData<MaterialMeshInfo>(mouseHover.CurrentEntity);
                mouseHover.OriginalRenderMeshes = EntityManager.GetSharedComponentManaged<RenderMeshArray>(mouseHover.CurrentEntity);

                // get render info from the hover entity
                var hoverMeshInfo = EntityManager.GetComponentData<MaterialMeshInfo>(mouseHover.HoverEntity);
                var hoverRenderMeshes = EntityManager.GetSharedComponentManaged<RenderMeshArray>(mouseHover.HoverEntity);

                // create new render info for the current entity that we hover over:

                // use the materials from the hover entity, but the meshes from the current entity
                var newRenderMeshes = new RenderMeshArray(hoverRenderMeshes.MaterialReferences, mouseHover.OriginalRenderMeshes.MeshReferences);

                // use the material id from the hover entity, but the mesh id from the current entity
                var newMeshInfo = MaterialMeshInfo.FromRenderMeshArrayIndices(hoverMeshInfo.Material, mouseHover.OriginalMeshInfo.Mesh);

                // apply the new render info to the current entity
                EntityManager.SetComponentData(mouseHover.CurrentEntity, newMeshInfo);
                EntityManager.SetSharedComponentManaged(mouseHover.CurrentEntity, newRenderMeshes);
            }
        }
    }
}

1. MouseHover (IComponentData)

// 관리되는 객체이므로 Class를 사용 
public class MouseHover : IComponentData
{
    public bool IgnoreTriggers;
    public bool IgnoreStatic;
    public Entity PreviousEntity; // 이전 프레임에서 Hover 상태의 Entity
    public Entity CurrentEntity; // 현재 프레임에서 Hover 상태의 Entity
    public Entity HoverEntity; // Hover 상태일 때 적용할 메쉬/머터리얼이 있는 Entity
    public MaterialMeshInfo OriginalMeshInfo; // 원래의 렌더링 정보를 저장
    public RenderMeshArray OriginalRenderMeshes; //   "
}

2. MouseHoverBaker (Baker)

[DisallowMultipleComponent]
public class MouseHoverAuthoring : MonoBehaviour
{
    public GameObject HoverPrefab;
    public bool IgnoreTriggers = true;
    public bool IgnoreStatic = true;

    // 참고: 편집기에서 구성 요소를 비활성화하려면 OnEnable을 재정의합니다
    protected void OnEnable() { }
}

// MouseHover 컴포넌트를 Entity에 추가
class MouseHoverBaker : Baker<MouseHoverAuthoring>
{
    public override void Bake(MouseHoverAuthoring authoring)
    {
        var entity = GetEntity(TransformUsageFlags.None);

        AddComponentObject(entity, new MouseHover()
        {
            PreviousEntity = Entity.Null,
            CurrentEntity = Entity.Null,
            IgnoreTriggers = authoring.IgnoreTriggers,
            IgnoreStatic = authoring.IgnoreStatic,
            HoverEntity = GetEntity(authoring.HoverPrefab, TransformUsageFlags.Dynamic), // HoverPrefab을 HoverEntity로 변환하여 저장
        });
    }
}

3. MouseHoverSystem (SystemBase)

    // Applies any mouse spring as a change in velocity on the entity's motion component
    // Limitations: works only if the physics objects in the scene come from the same subscene as MouseHoverAuthoring
    // Will be fixable if there is a Unity.Rendering API that lets you get the UnityEngine.Mesh that an entity is using for renderin.
    
    [UpdateInGroup(typeof(InitializationSystemGroup))]
    public partial class MouseHoverSystem : SystemBase
    {
        [BurstCompile]
        public struct WorldRaycastJob : IJob
        {
            public RaycastInput RayInput;
            [ReadOnly] public CollisionWorld CollisionWorld;
            [ReadOnly] public bool IgnoreTriggers;
            [ReadOnly] public bool IgnoreStatic;

            public NativeReference<RaycastHit> RaycastHitRef;

            public void Execute()
            {
                var mousePickCollector = new MousePickCollector(CollisionWorld.NumDynamicBodies)
                {
                    IgnoreTriggers = IgnoreTriggers,
                    IgnoreStatic = IgnoreStatic
                };

                if (CollisionWorld.CastRay(RayInput, ref mousePickCollector))
                {
                    RaycastHitRef.Value = mousePickCollector.Hit;
                }
            }
        }

        protected override void OnCreate()
        {
            base.OnCreate();
            RequireForUpdate<MouseHover>();
        }

        // Find the Entity holding the Graphical representation of a Physics Shape.
        // It may be that the Physics and Graphics representation are on the same Entity.
        public Entity FindGraphicsEntityFromPhysics(Entity bodyEntity) => FindGraphicsEntityFromPhysics(bodyEntity, ColliderKey.Empty);
        public Entity FindGraphicsEntityFromPhysics(Entity bodyEntity, ColliderKey leafColliderKey)
        {
            if (bodyEntity.Equals(Entity.Null))
            {
                // No Physics so no Graphics
                return Entity.Null;
            }

            // Set the Graphics Entity to the supplied Physics Entity
            var renderEntity = bodyEntity;

            // Check if we have hit a leaf node
            if (!leafColliderKey.Equals(ColliderKey.Empty))
            {
                // Get the Physics Collider
                var rootCollider = EntityManager.GetComponentData<PhysicsCollider>(bodyEntity).Value;

                // If we hit a CompoundCollider we need to find the original Entity associated
                // the actual leaf Collider that was hit.
                if (rootCollider.Value.Type == ColliderType.Compound)
                {
                    #region Find a Leaf Entity and ColliderKey
                    var leafEntity = Entity.Null;
                    unsafe
                    {
                        var rootColliderPtr = rootCollider.AsPtr();

                        // Get the leaf Collider and check if we hit was a PolygonCollider (i.e. a Triangle or a Quad)
                        rootColliderPtr->GetLeaf(leafColliderKey, out var childCollider);
                        leafEntity = childCollider.Entity;

                        // PolygonColliders are likely to not have an original Entity associated with them
                        // So if we have a Polygon and it has no Entity then we really need to check for
                        // the higher level Mesh or Terrain Collider instead.
                        var childColliderType = childCollider.Collider->Type;
                        var childColliderIsPolygon = childColliderType == ColliderType.Triangle || childColliderType == ColliderType.Quad;
                        if (childColliderIsPolygon && childCollider.Entity.Equals(Entity.Null))
                        {
                            // Get the ColliderKey of the Polygon's parent
                            if (TryGetParentColliderKey(rootColliderPtr, leafColliderKey, out leafColliderKey))
                            {
                                // Get the Mesh or Terrain Collider of the Polygon
                                TryGetChildInHierarchy(rootColliderPtr, leafColliderKey, out childCollider);
                                leafEntity = childCollider.Entity;
                            }
                        }
                    }
                    #endregion

                    // The Entities recorded in the leaves of a CompoundCollider may have been correct
                    // at the time of conversion. However, if the Collider blob is shared, or came up
                    // through a sub scene, we cannot assume that the baked Entities in the
                    // CompoundCollider are still valid.

                    // On conversion Entities using a CompoundCollider have an extra dynamic buffer added
                    // which holds a list of Entity/ColliderKey pairs. This buffer should be patched up
                    // automatically and be valid with each instance, at least until you start messing
                    // with the Entity hierarchy yourself e.g. by deleting Entities.

                    #region Check the Leaf Entity is valid
                    // If the leafEntity was never assigned in the first place
                    // there is no point in looking up any Buffers.
                    if (!leafEntity.Equals(Entity.Null))
                    {
                        // Check for an Key/Entity pair buffer first.
                        // This should exist if the Physics conversion pipeline was invoked.
                        var colliderKeyEntityPairBuffers = GetBufferLookup<PhysicsColliderKeyEntityPair>(true);
                        if (colliderKeyEntityPairBuffers.HasBuffer(bodyEntity))
                        {
                            var colliderKeyEntityBuffer = colliderKeyEntityPairBuffers[bodyEntity];
                            for (int i = 0; i < colliderKeyEntityBuffer.Length; i++)
                            {
                                var bufferColliderKey = colliderKeyEntityBuffer[i].Key;
                                if (leafColliderKey.Equals(bufferColliderKey))
                                {
                                    renderEntity = colliderKeyEntityBuffer[i].Entity;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            // We haven't found a Key/Entity pair buffer so the compound collider
                            // may have been created in code.

                            // We'll assume the Entity in the CompoundCollider is valid
                            renderEntity = leafEntity;

                            // If this CompoundCollider was instanced from a prefab then the entities
                            // in the compound children would actually reference the original prefab hierarchy.
                            var rootEntityFromLeaf = leafEntity;
                            while (SystemAPI.HasComponent<Parent>(rootEntityFromLeaf))
                            {
                                rootEntityFromLeaf = SystemAPI.GetComponent<Parent>(rootEntityFromLeaf).Value;
                            }

                            // If the root Entity found from the leaf does not match the body Entity
                            // then we have hit an instance using the same CompoundCollider.
                            // This means we can try and remap the leaf Entity to the new hierarchy.
                            if (!rootEntityFromLeaf.Equals(bodyEntity))
                            {
                                // This assumes there is a LinkedEntityGroup Buffer on original and instance Entity.
                                // No doubt there is a more optimal way of doing this remap with more specific
                                // knowledge of the final application.
                                var linkedEntityGroupBuffers = GetBufferLookup<LinkedEntityGroup>(true);

                                // Only remap if the buffers exist, have been created and are of equal length.
                                bool hasBufferRootEntity = linkedEntityGroupBuffers.HasBuffer(rootEntityFromLeaf);
                                bool hasBufferBodyEntity = linkedEntityGroupBuffers.HasBuffer(bodyEntity);
                                if (hasBufferRootEntity && hasBufferBodyEntity)
                                {
                                    var prefabEntityGroupBuffer = linkedEntityGroupBuffers[rootEntityFromLeaf];
                                    var instanceEntityGroupBuffer = linkedEntityGroupBuffers[bodyEntity];

                                    if (prefabEntityGroupBuffer.IsCreated && instanceEntityGroupBuffer.IsCreated
                                        && (prefabEntityGroupBuffer.Length == instanceEntityGroupBuffer.Length))
                                    {
                                        var prefabEntityGroup = prefabEntityGroupBuffer.AsNativeArray();
                                        var instanceEntityGroup = instanceEntityGroupBuffer.AsNativeArray();

                                        for (int i = 0; i < prefabEntityGroup.Length; i++)
                                        {
                                            // If we've found the renderEntity index in the prefab hierarchy,
                                            // set the renderEntity to the equivalent Entity in the instance
                                            if (prefabEntityGroup[i].Value.Equals(renderEntity))
                                            {
                                                renderEntity = instanceEntityGroup[i].Value;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }
            }

            // Finally check to see if we have a graphics redirection on the shape Entity.
            if (SystemAPI.HasComponent<PhysicsRenderEntity>(renderEntity))
            {
                renderEntity = SystemAPI.GetComponent<PhysicsRenderEntity>(renderEntity).Entity;
            }

            // If no render info is found on the located render entity, we try to find any child which has render info
            if (renderEntity != Entity.Null && !EntityManager.HasComponent<MaterialMeshInfo>(renderEntity))
            {
                // No render information on this entity. Try to find the actual render entity in the hierarchy.
                if (EntityManager.HasBuffer<Child>(renderEntity))
                {
                    var children = EntityManager.GetBuffer<Child>(renderEntity);
                    foreach (var childElement in children)
                    {
                        // find the first child with render info
                        if (EntityManager.HasComponent<MaterialMeshInfo>(childElement.Value))
                        {
                            renderEntity = childElement.Value;
                        }
                    }
                }
            }

            return renderEntity;
        }

        protected override void OnUpdate()
        {
            var collisionWorld = SystemAPI.GetSingleton<PhysicsWorldSingleton>().CollisionWorld;
            Vector2 mousePosition = Input.mousePosition;
            UnityEngine.Ray unityRay = Camera.main.ScreenPointToRay(mousePosition);
            var rayInput = new RaycastInput
            {
                Start = unityRay.origin,
                End = unityRay.origin + unityRay.direction * MousePickSystem.k_MaxDistance,
                Filter = CollisionFilter.Default,
            };

            var mouseHover = SystemAPI.ManagedAPI.GetSingleton<MouseHover>();

            RaycastHit hit;
            using (var raycastHitRef = new NativeReference<RaycastHit>(Allocator.TempJob))
            {
                var rcj = new WorldRaycastJob()
                {
                    CollisionWorld = collisionWorld,
                    RayInput = rayInput,
                    IgnoreTriggers = mouseHover.IgnoreTriggers,
                    IgnoreStatic = mouseHover.IgnoreStatic,
                    RaycastHitRef = raycastHitRef
                };
                rcj.Run();
                hit = raycastHitRef.Value;
            }

            var graphicsEntity = FindGraphicsEntityFromPhysics(hit.Entity, hit.ColliderKey);

            // If still hovering over the same entity then do nothing.
            if (mouseHover.CurrentEntity.Equals(graphicsEntity)) return;

            mouseHover.PreviousEntity = mouseHover.CurrentEntity;
            mouseHover.CurrentEntity = graphicsEntity;

            bool hasPreviousEntity = !mouseHover.PreviousEntity.Equals(Entity.Null);
            bool hasCurrentEntity = !mouseHover.CurrentEntity.Equals(Entity.Null);

            if (hasPreviousEntity && EntityManager.HasComponent<MaterialMeshInfo>(mouseHover.PreviousEntity))
            {
                // restore render info to original in the last entity we were hovering over
                EntityManager.SetComponentData(mouseHover.PreviousEntity, mouseHover.OriginalMeshInfo);
                EntityManager.SetSharedComponentManaged(mouseHover.PreviousEntity, mouseHover.OriginalRenderMeshes);
            }

            if (hasCurrentEntity && EntityManager.HasComponent<MaterialMeshInfo>(mouseHover.CurrentEntity) && EntityManager.HasComponent<RenderMeshArray>(mouseHover.CurrentEntity))
            {
                mouseHover.PreviousEntity = mouseHover.CurrentEntity;
                mouseHover.CurrentEntity = graphicsEntity;
                mouseHover.OriginalMeshInfo = EntityManager.GetComponentData<MaterialMeshInfo>(mouseHover.CurrentEntity);
                mouseHover.OriginalRenderMeshes = EntityManager.GetSharedComponentManaged<RenderMeshArray>(mouseHover.CurrentEntity);

                // get render info from the hover entity
                var hoverMeshInfo = EntityManager.GetComponentData<MaterialMeshInfo>(mouseHover.HoverEntity);
                var hoverRenderMeshes = EntityManager.GetSharedComponentManaged<RenderMeshArray>(mouseHover.HoverEntity);

                // create new render info for the current entity that we hover over:

                // use the materials from the hover entity, but the meshes from the current entity
                var newRenderMeshes = new RenderMeshArray(hoverRenderMeshes.MaterialReferences, mouseHover.OriginalRenderMeshes.MeshReferences);

                // use the material id from the hover entity, but the mesh id from the current entity
                var newMeshInfo = MaterialMeshInfo.FromRenderMeshArrayIndices(hoverMeshInfo.Material, mouseHover.OriginalMeshInfo.Mesh);

                // apply the new render info to the current entity
                EntityManager.SetComponentData(mouseHover.CurrentEntity, newMeshInfo);
                EntityManager.SetSharedComponentManaged(mouseHover.CurrentEntity, newRenderMeshes);
            }
        }
    }

1) InitializationSystemGroup

초기화 단계에서 실행됨

2) WorldRaycastJob (IJob)

마우스 위치에서 Raycast를 실행하는 IJob

• CollisionWorld.CastRay()를 사용하여 마우스가 클릭한 지점의 물리 객체를 찾음
• mousePickCollector를 사용하여 필터링 (IgnoreTriggers, IgnoreStatic)

3) OnUpdate()

1> CollisionWorld 가져오기

• PhysicsWorldSingleton은 Unity Physics 시스템에서 현재의 물리 월드(CollisionWorld)를 관리하는 싱글톤
• CollisionWorld는 물리적인 충돌을 검사하는 데 사용

2> 마우스 위치에서 레이(Ray) 생성

• Input.mousePosition을 사용하여 현재 마우스 커서의 화면 좌표를 가져오기
• Camera.main.ScreenPointToRay(mousePosition)을 통해 이 화면 좌표를 기준으로 3D 월드에서의 Ray를 생성

3> RaycastInput 설정

RaycastInput은 Unity Physics에서 사용되는 구조체로, 물리 엔진이 사용할 레이캐스트 정보를 포함

• Start: 레이의 시작점 (unityRay.origin)
• End: 레이의 끝점 (unityRay.origin + unityRay.direction * MousePickSystem.k_MaxDistance)
  • MousePickSystem.k_MaxDistance는 레이의 최대 탐색 거리로, 너무 멀리까지 체크하지 않도록 제한
• Filter: CollisionFilter.Default는 기본적인 충돌 필터로, 충돌 검사를 수행할 물리 레이어를 정의

4> MouseHover 컴포넌트 가져오기

• MouseHover는 마우스 오버 이벤트를 관리하는 IComponentData
• SystemAPI.ManagedAPI.GetSingleton<MouseHover>()을 사용하여 현재 씬에 존재하는 MouseHover 컴포넌트를 가져옴

5> 레이캐스트 실행

NativeReference<RaycastHit>을 사용하여 레이캐스트 결과(RaycastHit)를 저장할 공간을 확보

WorldRaycastJob을 생성하여 레이캐스트를 수행

• CollisionWorld을 사용하여 실제 물리 충돌을 검사합니다.
• IgnoreTriggers, IgnoreStatic 값을 기반으로 충돌 조건을 설정합니다.

rcj.Run();을 실행하여 Job을 즉시 수행한 후 결과를 hit에 저장합니다.

5> 물리 Entity에서 그래픽 Entity 찾기

hit.Entity는 RaycastHit 결과에서 얻은 충돌한 물리 Entity

FindGraphicsEntityFromPhysics(hit.Entity, hit.ColliderKey)를 호출하여 실제 렌더링을 담당하는 Entity를 찾습니다.

• 물리 Entity 와 그래픽 Entity 는 다를 수 있기 때문에 이 과정을 거칩니다.

6> 동일한 엔터티를 계속 가리키면 무시

현재 마우스가 가리키는 graphicsEntity가 이전 프레임과 동일하면 추가 작업을 하지 않고 바로 반환합니다.

7> 이전 및 현재 마우스 오버 Entity 업데이트

• PreviousEntity에 이전 프레임에서 마우스가 가리키던 Entity를 저장합니다.
• CurrentEntity에 이번 프레임에서 새롭게 감지된 Entity를 저장합니다.

8> 이전 Entity의 원래 상태 복구

hasPreviousEntity: 이전 프레임에서 마우스가 가리키던 Entity가 존재하는지 확인

EntityManager.HasComponent<MaterialMeshInfo>(mouseHover.PreviousEntity): 이전 Entity가 MaterialMeshInfo 컴포넌트를 가지고 있는지 확인

이전 Entity의 렌더링 데이터를 원래 값으로 복원:

• MaterialMeshInfo: 이전에 저장해 둔 원래의 메쉬 정보를 복원
• RenderMeshArray: 이전에 저장해 둔 원래의 Material 배열을 복원

9> 새로운 Entity의 마우스 Hover 효과 적용

현재 프레임에서 감지된 CurrentEntity가 존재하는지 확인

MaterialMeshInfo 및 RenderMeshArray 컴포넌트가 있는 경우, 원래 상태를 저장:

• OriginalMeshInfo: 원래 MaterialMeshInfo 값을 저장
• OriginalRenderMeshes: 원래 RenderMeshArray 값을 저장

10> 마우스 Hover 머티리얼 적용

mouseHover.HoverEntity는 마우스 Hover 효과를 표시하는 데 사용할 프리팹(Material 정보 포함)

hoverMeshInfo와 hoverRenderMeshes를 가져와서 현재 마우스가 가리키는 Entity에 적용

The post ECS – MouseHoverAuthoring appeared first on 어제와 내일의 나 그 사이의 이야기.

ECS – BufferTypeHandle

ECS에서 DynamicBuffer<T>를 처리하려면 BufferTypeHandle<T>를 사용해야 한다.

즉, “IComponentData가 아닌 버퍼 데이터를 읽고/쓰는 Handle“

1. BufferTypeHandle<T>란?

• ECS에서 DynamicBuffer<T>를 읽고/쓰기 위한 Handle
• IJobChunk 내부에서 사용됨
• GetBufferAccessor(ref BufferTypeHandle<T>)를 이용해 버퍼 데이터 접근
• 쓰기 여부에 따라 읽기 전용(true) / 읽기+쓰기(false) 로 설정 가능

2. 사용 예제

1) OnCreate()에서 초기화

_BufferTypeHandle = state.GetBufferTypeHandle<GridCellBufferComponent>(isReadOnly: false);

• isReadOnly: true → 읽기 전용
• isReadOnly: false → 읽기 & 쓰기 가능

2) OnUpdate()에서 매 프레임 업데이트

_BufferTypeHandle.Update(ref state);

• Update(ref state)를 호출해야 최신 데이터를 가져올 수 있다.

3. BufferTypeHandle 상세 사용법

1) 기본 사용법 (IJobChunk에서 사용)

[BurstCompile]
public struct CountJob : IJobChunk
{
    public BufferTypeHandle<GridCellBufferComponent> BufferTypeHandle;

    public void Execute(in ArchetypeChunk chunk, int chunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
    {
        var buffers = chunk.GetBufferAccessor(ref BufferTypeHandle);

        for (int i = 0; i < chunk.Count; i++)
        {
            DynamicBuffer<GridCellBufferComponent> buffer = buffers[i];

            for (int j = 0; j < buffer.Length; j++)
            {
                buffer[j] = new GridCellBufferComponent
                {
                    Position = buffer[j].Position,
                    IsOccupied = buffer[j].IsOccupied,
                    Count = buffer[j].Count + 1 // Count 증가
                };
            }
        }
    }
}

• chunk.GetBufferAccessor(ref BufferTypeHandle)을 사용하여 DynamicBuffer에 접근
• 각 chunk에 속한 모든 DynamicBuffer<GridCellBufferComponent>에 대해 반복문 실행

2) OnUpdate()에서 ScheduleParallel 실행

public void OnUpdate(ref SystemState state)
{
    _BufferTypeHandle.Update(ref state);

    var job = new CountJob
    {
        BufferTypeHandle = _BufferTypeHandle
    };

    state.Dependency = job.ScheduleParallel(_GridQuery, state.Dependency);
}

• _BufferTypeHandle.Update(ref state); → 최신 상태 반영
• ScheduleParallel() → 여러 개의 chunk를 병렬 실행

3) IJobParallelFor에서 BufferTypeHandle를 사용할 때

일반적으로 IJobParallelFor에서는 직접 사용할 수 없고, AsNativeArray() 를 사용해야 함.

[BurstCompile]
public struct CountJobParallelFor : IJobParallelFor
{
    public NativeArray<GridCellBufferComponent> BufferNativeArray;

    public void Execute(int index)
    {
        BufferNativeArray[index] = new GridCellBufferComponent
        {
            Position = BufferNativeArray[index].Position,
            IsOccupied = BufferNativeArray[index].IsOccupied,
            Count = BufferNativeArray[index].Count + 1
        };
    }
}

OnUpdate()에서 실행:

public void OnUpdate(ref SystemState state)
{
    _BufferTypeHandle.Update(ref state);
    var chunks = _GridQuery.ToArchetypeChunkArray(Allocator.TempJob);

    for (int i = 0; i < chunks.Length; i++)
    {
        BufferAccessor<GridCellBufferComponent> bufferAccessor = chunks[i].GetBufferAccessor(ref _BufferTypeHandle);
        for (int j = 0; j < bufferAccessor.Length; j++)
        {
            DynamicBuffer<GridCellBufferComponent> buffer = bufferAccessor[j];

            var job = new CountJobParallelFor
            {
                BufferNativeArray = buffer.AsNativeArray()
            };

            job.Schedule(buffer.Length, 1).Complete(); // 즉시 실행
        }
    }
    chunks.Dispose();
}

주의할 점

• DynamicBuffer<T>에서 AsNativeArray() 를 호출하여 IJobParallelFor에서 사용
• .Complete() 없이 state.Dependency = job.Schedule();을 하면 Write Conflict 에러 발생
• buffer.AsNativeArray()는 해당 프레임에서만 유효

4. BufferTypeHandle 요약

BufferTypeHandle<T>는 언제 사용?

• 많은 데이터가 DynamicBuffer에 저장될 때
• ECS에서 IJobChunk 또는 IJobParallelFor을 활용할 때
• 최대 성능을 끌어내기 위해 ScheduleParallel을 사용할 때

The post ECS – BufferTypeHandle appeared first on 어제와 내일의 나 그 사이의 이야기.

ECS – System concepts

https://docs.unity3d.com/Packages/com.unity.entities@1.3/manual/concepts-systems.html

System concepts

System의 역할

• System은 컴포넌트 데이터를 읽고, 수정하여 프레임마다 업데이트하는 역할을 수행
• OnUpdate()가 매 프레임 호출되며, Entity 데이터를 갱신함
• SystemBase(관리형 시스템)와 ISystem(비관리형 시스템) 두 가지 유형이 있음

System의 유형

System 실행 순서 (System Groups)

• ECS는 시스템을 Auto Bootstrap하며, 기본적으로 3가지 그룹으로 실행됨.
  (Auto Bootstrap – 시스템을 자동으로 생성하고 실행하는 과정)

• 특정 그룹에서 실행되도록 하려면 [UpdateInGroup(typeof(그룹))] 속성을 사용.

SystemBase 예제 (관리형 시스템)

using Unity.Burst;
using Unity.Entities;
using Unity.Transforms;
using Unity.Mathematics;
using UnityEngine;

// [UpdateInGroup(typeof(SimulationSystemGroup))]  // 특정 그룹에서 실행 가능
public partial class MoveSystem : SystemBase
{
    protected override void OnUpdate()
    {
        float deltaTime = SystemAPI.Time.DeltaTime; // 현재 프레임의 Delta Time

        Entities.ForEach((ref LocalTransform transform) =>
        {
            transform.Position += new float3(1, 0, 0) * deltaTime; // X축 이동
        }).ScheduleParallel();
    }
}

ISystem 예제 (비관리형 시스템)

using Unity.Burst;
using Unity.Entities;
using Unity.Transforms;
using Unity.Mathematics;

// 성능 최적화를 위해 [BurstCompile] 적용
[BurstCompile]
public partial struct MoveSystem_ISystem : ISystem
{
    public void OnCreate(ref SystemState state) { }  // 초기화

    public void OnDestroy(ref SystemState state) { } // 시스템 종료 시 실행

    public void OnUpdate(ref SystemState state)
    {
        float deltaTime = SystemAPI.Time.DeltaTime;

        foreach (var transform in SystemAPI.Query<RefRW<LocalTransform>>())
        {
            transform.ValueRW.Position += new float3(1, 0, 0) * deltaTime;
        }
    }
}

System 실행 순서 제어 (System Group 활용)

using Unity.Entities;

[UpdateInGroup(typeof(InitializationSystemGroup))] // 초기화 단계에서 실행
public partial class InitSystem : SystemBase
{
    protected override void OnUpdate()
    {
        UnityEngine.Debug.Log("초기화 시스템 실행됨!");
    }
}

Inspecting systems

시스템 창을 사용하여 각 세계의 시스템 업데이트 순서를 검사하고 시스템 그룹의 전체 계층을 볼 수 있습니다.

자세한 내용은 Systems window reference를 참조하세요.

에디터에서 Systems

편집기에서 다음 아이콘은 다양한 유형의 시스템을 나타냅니다.

 Entities windows와 Inspectors를 사용하면 이를 확인할 수 있습니다.

Icon	Represents
	A system group
	A system
	OrderFirst 인수를 사용하여 시스템 그룹의 시작 시 실행되도록 설정된 Entity 명령 버퍼 시스템
	OrderLast 인수를 사용하여 시스템 그룹의 끝에서 실행되도록 설정된 엔티티 명령 버퍼 시스템입니다.

The post ECS – System concepts appeared first on 어제와 내일의 나 그 사이의 이야기.