Function emitServerInstanceMethod

scripts/codegen/csharp.ts:1815–1945

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

}

function emitServerInstanceMethod(
    name: string,
    method: RpcMethod,
    lines: string[],
    classes: string[],
    indent: string,
    groupExperimental: boolean,
    groupDeprecated: boolean
): void {
    const methodName = toPascalCase(name);
    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) : [];
    const requiredSet = new Set(effectiveParams?.required || []);

    // 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;
    });

    let requestClassName: string | null = null;
    if (paramEntries.length > 0) {
        requestClassName = paramsTypeName(method);
        if (method.stability === "experimental" && !nonExperimentalRpcTypes.has(requestClassName)) {
            experimentalRpcTypes.add(requestClassName);
        }
        const reqClass = emitRpcClass(requestClassName, effectiveParams!, "internal", classes);
        if (reqClass) classes.push(reqClass);
    }

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

    for (const [pName, pSchema] of paramEntries) {
        if (typeof pSchema !== "object") continue;
        const isReq = requiredSet.has(pName);
        const jsonSchema = pSchema as JSONSchema7;
        const csharpName = requestClassName
            ? toCSharpPropertyName(pName, jsonSchema)
            : toPascalCase(pName);
        const naturalType = requestClassName
            ? resolveRpcType(jsonSchema, isReq, requestClassName, csharpName, classes)
            : schemaTypeToCSharp(jsonSchema, isReq, rpcKnownTypes, csharpName);
        // Boundary special-case: if the natural type is JsonElement/JsonElement?