使用底部类型而不是顶部类型。
unknown是顶层类型：它包含了所有可能的值。一个带有unknown类型参数的函数应该接受任何值作为参数。一个只接受 some 类型值的函数不可能符合(_: unknown) => void;然而，对于任何T，函数(_: unknown) => void将符合(_: T) => void，因此我们有T是unknown的子类型，但另一方面，(_: unknown) => void是(_: T) => void的子类型，这种情况被称为 * 逆变 *，并且我们说将T取为取T的函数类型的类型构造函数在T中是 * 逆变 * 的。
在您的示例中，由于Operation<T>的定义指定了一个属性，该属性的函数类型采用T，因此Operation<T>在T中也是逆变的，这意味着对于任何其他T，Operation<unknown>都是Operation<T>的 * 子类型 。 而不是 * 您想要的超类型。（当您更改Operation<T>以包含类型仅为T的属性时，它在T中变成了 * 协变 *，这意味着子类型关系是 * 不 * 反转的。）
相反，您可以使用Operation<never>：

export interface Operation<Context> {
    process: (context: Context) => void;
    n: number;
}

type MyContext = {
    info: string;
}

const op : Operation<MyContext> = {
    process: (context: MyContext) =>
        { console.log("process", context.info); },
    n: 42
}

function fNever(op: Operation<never>): void {
    console.log("fNever", op.n);
}

console.log(fNever(op));

底层类型never不包含任何值，是所有类型的子类型。因为Operation<T>在T中是逆变的，这意味着Operation<never>是所有Operation<T>的超类型。在更简单的语言中，通过使用Operation<never>，您不需要process可以用任何特定的东西调用。实际上你保证永远不会调用process因为never不包含值，所以接受never参数的函数是不可调用的。

不能将Operation<MyContext>传递给参数类型为Operation<unknown>的函数，因为该函数可能会尝试非法修改该参数。如下所示：

function fUnknown(op: Operation<unknown>): void {
    const foo: unknown = "Mystery";
    op.context = foo;
    console.log("fUnknown", op.n);
}

您可能应该这样做：

function fUnknown2<T extends unknown>(op: Operation<T>): void {
    const foo: unknown = "Mystery";
    /* Would cause "Type 'unknown' is not assignable to type 'T'.
  'unknown' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'unknown'."
    op.context = foo; */
    console.log("fUnknown", op.n);
}

它不能编译的原因是函数参数是逆变的，并且Operation在函数参数位置使用Context类型参数。
当您将op传递给fUnknown时，op声称它只能与MyContext一起工作，但是fUnknown要求传递给它的Operation可以与任何东西一起工作，而不仅仅是MyContext。
您可以通过多种方式解决此问题：

• 需要Operation<any>：如果在函数体或签名的其余部分中根本不使用泛型信息，这是完全有效的选择
• 需要Operation<MyContext>：它不是很通用
• 要求Operation<T>，并让T被推断：当您传递op时，T将变为MyContext，并且您可以在函数主体/签名中使用T是泛型的信息