Function emitSessionMethod

scripts/codegen/csharp.ts:1984–2116

(key: string, method: RpcMethod, lines: string[], classes: string[], indent: string, groupExperimental: boolean, groupDeprecated: boolean)

}

function emitSessionMethod(key: string, method: RpcMethod, lines: string[], classes: string[], indent: string, groupExperimental: boolean, groupDeprecated: boolean): void {
    const methodName = toPascalCase(key);
    const isInternal = method.visibility === "internal";
    const methodVisibility = isInternal ? "internal" : "public";
    const resultSchema = getMethodResultSchema(method);
    let resultClassName = !isVoidSchema(resultSchema) ? resultTypeName(method) : "";
    if (!isVoidSchema(resultSchema) && method.stability === "experimental" && !nonExperimentalRpcTypes.has(resultClassName)) {
        experimentalRpcTypes.add(resultClassName);
    }
    if (!isVoidSchema(resultSchema)) {
        resultClassName = emitRpcResultType(resultClassName, resultSchema!, methodVisibility, classes);
    }

    const effectiveParams = resolveMethodParamsSchema(method);
    const paramEntries = (effectiveParams?.properties ? Object.entries(effectiveParams.properties) : []).filter(([k]) => k !== "sessionId");
    const requiredSet = new Set(effectiveParams?.required || []);
    const useRequestParameter =
        paramEntries.length > 0 &&
        !!getNullableInner(method.params) &&
        paramEntries.every(([name]) => !requiredSet.has(name));

    // Sort so required params come before optional (C# requires defaults at end)
    paramEntries.sort((a, b) => {
        const aReq = requiredSet.has(a[0]) ? 0 : 1;
        const bReq = requiredSet.has(b[0]) ? 0 : 1;
        return aReq - bReq;
    });

    const requestClassName = paramsTypeName(method);
    const wireRequestClassName = useRequestParameter ? `${requestClassName}WithSession` : requestClassName;
    if (method.stability === "experimental" && !nonExperimentalRpcTypes.has(requestClassName)) {
        experimentalRpcTypes.add(requestClassName);
        if (useRequestParameter && !nonExperimentalRpcTypes.has(wireRequestClassName)) {
            experimentalRpcTypes.add(wireRequestClassName);
        }
    }
    if (effectiveParams?.properties && Object.keys(effectiveParams.properties).length > 0) {
        if (useRequestParameter) {
            const publicParams: JSONSchema7 = {
                ...effectiveParams,
                properties: Object.fromEntries(paramEntries),
                required: effectiveParams.required?.filter((name) => name !== "sessionId"),
            };
            const publicReqClass = emitRpcClass(requestClassName, publicParams, methodVisibility, classes);
            if (publicReqClass) classes.push(publicReqClass);
            const wireReqClass = emitRpcClass(wireRequestClassName, effectiveParams, "internal", classes);
            if (wireReqClass) classes.push(wireReqClass);
        } else {
            const reqClass = emitRpcClass(requestClassName, effectiveParams, "internal", classes);
            if (reqClass) classes.push(reqClass);
        }
    }

    const sigParams: string[] = [];
    const bodyAssignments = [`SessionId = _session.SessionId`];
    const argumentNullChecks: string[] = [];
    const parameterDescriptions: Array<{ name: string; description?: string; escapeDescription?: boolean }> = [];