我不知道是否有一个替代的策略或Typescript的特性可以利用，但由于我时间有限，我只会在这里回答为什么你的方法不起作用。
在您的代码中，ConstructorParameters<typeof Parent>中的项Parent不受G类型参数的约束。因此它的隐式类型是Parent<unknown>。
在Child<G>中声明的G类型参数只约束代码中的两件事：
1.子类扩展的类型，即Parent<G>
1.在ctor中对super调用的预期args。这是从#1开始。如果您将鼠标悬停在IDE中的super上，它将显示：

constructor Parent<G>(stringField: String, genericField: G): Parent<G>

要进一步确认/理解发生了什么，请将class Parent<T>更改为class Parent<T extends number>，并查看错误如何更改。我上面说的话现在应该完全清楚了。
解决这个问题的最明显的方法是使用G类型参数来约束ConstructorParameters，例如：

class Child<G> extends Parent<G> {
    numberField: Number;

    constructor(numberField: Number, ...params:ConstructorParameters<typeof Parent<G>>) {
        super(...params);
        this.numberField = numberField;
    }
}

但是Typescript不支持这种语法，甚至不支持语义。
也许有一种方法可以使用infer或定义一个绑定到Parent的自定义ConstructorParameters，但我现在没有时间玩这个。
这是一个有趣的问题。我认为TS会有一个解决方案，或者会想要有一个解决方案。我将向TS团队提交问题以获得支持

ConstructorParameters<typeof Parent<G>>

你可能会得到一个“好主意！”的回答，或者你的问题的解决方案（指向这个SO问题）。如果您确实提交了一个问题，请在您的问题中发布一个链接。
希望比我聪明的人能看到这一点，并提出解决方案。
祝你好运

在TS版本4.3.5中创建了我自己的实用程序类型来解决这个问题。在处理泛型时，我使用它来代替常规的ConstructorParameters，它看起来具有很好的可扩展性，不过如果您想确定的话，请务必阅读解释部分。下面是一个带有helper的文件，沿着几个示例playgrounds：

泛型构造函数参数.ts

// helpers
type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N; 
type IsUnknown<T> = unknown extends T ? IfAny<T, never, true> : never;
type UnknownReplacer<T, K> = K extends [infer WithThis, ...infer WithRest] ? T extends [infer ReplaceThis, ...infer ReplaceRest] ? IsUnknown<ReplaceThis> extends never ? [ReplaceThis, ...UnknownReplacer<ReplaceRest, K>] : [WithThis, ...UnknownReplacer<ReplaceRest, WithRest>] : []: T

// GenericConstructorParameters: Takes two arguments
// Arg 1. a constructor
// Arg 2. a tuple of types (one type for each generic in the constructor)
type GenericConstructorParameters<T extends abstract new (...args: any) => any, K> = UnknownReplacer<ConstructorParameters<T>, K>

下面是我最初问题中的类的实际情况：Playground链接
这里是如果Parent类接受多个泛型：Playground链接

为什么会这样

GenericConstructorParameters有两个参数。它的工作原理是在第一个参数（构造函数，就像ConstructorParameters的第一个参数）上调用ConstructorParameters，以获取构造函数参数类型的元组。因为泛型在被ConstructorParameters提取时变成了unknown，所以我们用第二个参数提供的类型（替换类型的元组）替换结果元组中的每个unknown类型。
请注意，虽然我只见过unknown在泛型类上调用ConstructorParameters时替换泛型，但我不知道是否在 every 场景中都能保证这一点。所以我希望其他人能证明。
如果这是正确的，那么可靠地确定什么是或不是真正的unknown是下一步要做的事情。我创建了IsUnknown实用程序类型（为了便于阅读，在下面进行了扩展）来实现这一点，并得到了来自this SO answer的IfAny实用程序的帮助。然而，这是另一个不确定这在每一个场景中都有效的例子。如果是这样的话，那么这应该意味着它是可伸缩的，并且无论我的超类使用什么其他类型，包括any类型，都应该工作。

type IsUnknown<T> =
  unknown extends T         // unknown only extends either itself or any (I think)
    ? IfAny<T, never, true> // so if we can narrow it down, just check if it is any
    : never;

我创建了UnknownReplacer实用程序（为了便于阅读，在下面进行了扩展）来完成大部分后续工作。多亏了this SO answer，我知道了如何对可变元组进行递归，通过它，我可以用替换元组中下一个未使用的类型替换构造函数参数中的未知数。

type UnknownReplacer<T, K> =
  K extends [infer WithThis, ...infer WithRest]                   // if K is a populated tuple of types (i.e. one for each unknown to replace)
    ? T extends [infer ReplaceThis, ...infer ReplaceRest]         // ...then if T is a populated tuple of types (i.e. from our constructor arguments)
      ? IsUnknown<ReplaceThis> extends never                      // ......then check if the first type in T is NOT unknown
        ? [ReplaceThis, ...UnknownReplacer<ReplaceRest, K>]       // .........and if not unknown, return the first type from T with a recursive call on the remaining args from T
        : [WithThis, ...UnknownReplacer<ReplaceRest, WithRest>]   // .........but if it is unknown, return the first type from K with a recursive call on the remaining args from T and K 
      : []                                                        // ......but if T is empty (or invalid), return an empty tuple as we've run out of things to check
    : T                                                           // ...but if K is empty (or invalid), return T as there's nothing we can use to replace anyway

最后，GenericConstructorParameters类型只是将这些东西很好地 Package 在一起。
我不知道这个用例有多小众，或者是否有人以前解决过这个问题，但我希望这是（实际上是正确的），能够帮助其他人解决同样的问题。
寻找反馈！

这也可以工作，并且更易于管理

type GenericConstructorParameters<T> = ConstructorParameters<new ( ...args: any[] ) => T>