string?StoreSimpleValue_CorDebug(DbgEvaluationInfo evalInfo, ILDbgEngineStackFrame ilFrame, Func <CreateCorValueResult> createTargetValue, DmdType targetType, object?sourceValue)
        {
            Debug.Assert(RequiresNoFuncEvalToStoreValue(targetType, sourceValue));
            evalInfo.CancellationToken.ThrowIfCancellationRequested();
            CreateCorValueResult createResult = default;

            try {
                var dnThread = GetThread(evalInfo.Frame.Thread);
                createResult = createTargetValue();
                if (createResult.Value is null)
                {
                    return(CordbgErrorHelper.GetErrorMessage(createResult.HResult));
                }
                return(StoreSimpleValue_CorDebug(dnThread, createResult.Value, targetType, sourceValue));
            }
            catch (TimeoutException) {
                return(PredefinedEvaluationErrorMessages.FuncEvalTimedOut);
            }
            catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex))
            {
                return(CordbgErrorHelper.InternalError);
            }
            finally {
                if (createResult.CanDispose)
                {
                    dnDebugger.DisposeHandle(createResult.Value);
                }
            }
        }
        internal string?StoreValue_CorDebug(DbgEvaluationInfo evalInfo, ILDbgEngineStackFrame ilFrame, Func <CreateCorValueResult> createTargetValue, DmdType targetType, object?sourceValue)
        {
            debuggerThread.VerifyAccess();

            if (RequiresNoFuncEvalToStoreValue(targetType, sourceValue))
            {
                return(StoreSimpleValue_CorDebug(evalInfo, ilFrame, createTargetValue, targetType, sourceValue));
            }

            evalInfo.CancellationToken.ThrowIfCancellationRequested();
            var tmp = CheckFuncEval(evalInfo);

            if (!(tmp is null))
            {
                return(tmp.Value.ErrorMessage ?? throw new InvalidOperationException());
            }

            var dnThread      = GetThread(evalInfo.Frame.Thread);
            var createdValues = new List <CorValue>();
            CreateCorValueResult createResult = default;

            try {
                var appDomain           = ilFrame.GetCorAppDomain();
                var reflectionAppDomain = targetType.AppDomain;
                using (var dnEval = dnDebugger.CreateEval(evalInfo.CancellationToken, suspendOtherThreads: (evalInfo.Context.Options & DbgEvaluationContextOptions.RunAllThreads) == 0)) {
                    dnEval.SetThread(dnThread);
                    dnEval.SetTimeout(evalInfo.Context.FuncEvalTimeout);
                    dnEval.EvalEvent += (s, e) => DnEval_EvalEvent(dnEval, evalInfo);

                    var converter = new EvalArgumentConverter(this, dnEval, appDomain, reflectionAppDomain, createdValues);

                    var evalRes = converter.Convert(sourceValue, targetType, out var newValueType);
                    if (!(evalRes.ErrorMessage is null))
                    {
                        return(evalRes.ErrorMessage);
                    }

                    var sourceCorValue = evalRes.CorValue !;
                    var sourceType     = new ReflectionTypeCreator(this, reflectionAppDomain).Create(sourceCorValue.ExactType);

                    createResult = createTargetValue();
                    if (createResult.Value is null)
                    {
                        return(CordbgErrorHelper.GetErrorMessage(createResult.HResult));
                    }
                    return(StoreValue_CorDebug(dnEval, createdValues, appDomain, dnThread, createResult.Value, targetType, sourceCorValue, sourceType));
                }
            }
            catch (TimeoutException) {
                return(PredefinedEvaluationErrorMessages.FuncEvalTimedOut);
            }
            catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex))
            {
                return(CordbgErrorHelper.InternalError);
            }
            finally {
                if (createResult.CanDispose)
                {
                    dnDebugger.DisposeHandle(createResult.Value);
                }
                foreach (var v in createdValues)
                {
                    dnDebugger.DisposeHandle(v);
                }
            }
        }