我不知道TypeScript，所以我不能用同一种语言回答，但是如果你想让你的Provider“特定于”你的MyList类，你可以在同一个函数中创建这两个Provider。

function makeList() {
  const Ctx = React.createContext();

  class MyList extends Component {
    // ...
    render() {
      return (
        <Ctx.Provider value={this.state.something}>
          {this.props.children}
        </Ctx.Provider>
      );
    }
  }

  return {
    List,
    Consumer: Ctx.Consumer 
  };
}

// Usage
const { List, Consumer } = makeList();

总的来说，我认为你可能过于抽象了。在React组件中大量使用泛型不是一种很常见的风格，可能会导致相当混乱的代码。

我也遇到过同样的问题，我想我用了一种更优雅的方式解决了它：您可以使用lodash once（或者自己创建一个，这非常简单）使用泛型类型初始化上下文，然后从函数内部调用它，在其余组件中，您可以使用自定义useContext钩子来获取数据：

父组件：

import React, { useContext } from 'react';
import { once } from 'lodash';

const createStateContext = once(<T,>() => React.createContext({} as State<T>));
export const useStateContext = <T,>() => useContext(createStateContext<T>());

const ParentComponent = <T>(props: Props<T>) => {
    const StateContext = createStateContext<T>();
    return (
        <StateContext.Provider value={[YOUR VALUE]}>
            <ChildComponent />
        </StateContext.Provider>
    );
}

子组件：

import React from 'react';
import { useStateContext } from './parent-component';

const ChildComponent = <T>(props: Props<T>) => {
     const state = useStateContext<T>();
     ...
}

希望能帮到什么人

不幸的是，我认为答案是这个问题实际上没有意义。
让我们退一步说对于一个通用的上下文来说，这意味着什么？一些代表生产者的上下文的组件Producer<T>可能只提供T类型的值，对吗？
现在考虑以下内容：

<Producer<string> value="123">
  <Producer<number> value={123}>
    <Consumer />
  </Producer>
</Producer>

这应该如何表现？消费者应该得到什么样的价值？
1.如果Producer<number>覆盖Producer<string>（即消费者得到123），泛型类型不做任何事情。在生产者级别调用它number并不强制你在消费时得到number，所以指定它是徒劳的。
1.如果两个生产者是完全独立的（例如，消费者得到"123"），那么它们必须来自两个独立的上下文示例，这两个示例特定于它们所拥有的类型。
在这两种情况下，将类型直接传递给Producer都没有任何价值。这并不是说当上下文起作用时泛型就没用了...

如何创建通用列表组件？

作为一个已经使用了一段时间泛型组件的人，我不认为你的列表示例过于抽象，只是你不能强制生产者和消费者之间的类型协议--就像你不能“强制”从Web请求、本地存储或第三方代码中获得的值的类型一样！
最终，这意味着在定义Context时使用类似any的内容，并在使用该Context时指定一个 expected 类型。

示例

const listContext = React.createContext<ListProps<any>>({ onSelectionChange: () => {} });

interface ListProps<TItem> {
  onSelectionChange: (selected: TItem | undefined) => void;
}

// Note that List is still generic! 
class List<TItem> extends React.Component<ListProps<TItem>> {
    public render() {
        return (
            <listContext.Provider value={this.props}>
                {this.props.children}
            </listContext.Provider>
        );
    }
}

interface CustomListItemProps<TItem> {
  item: TItem;
}

class CustomListItem<TItem> extends React.Component<CustomListItemProps<TItem>> {
    public render() {
        // Get the context value and store it as ListProps<TItem>.
        // Then build a list item that can call onSelectionChange based on this.props.item!
    }
}

interface ContactListProps {
  contacts: Contact[];
}

class ContactList extends React.Component<ContactListProps> {
    public render() {
        return (
            <List<Contact> onSelectionChange={console.log}>
                {contacts.map(contact => <ContactListItem contact={contact} />)}
            </List>
        );
    }
}

检查Formik如何给药

对我来说，在使用上下文（useContext）时检查类型很重要，就像Formik useFormikContext一样。

泛型类型示例

type YourContextType<T> = { state: T; setState: (s: T) => void }

创建上下文（不关心类型）

const YourContext = createContext<YourContextType<any>>(
  undefined as any,
);

具有泛型类型的上下文挂接

function useYourContext<T>() {
  const context = useContext<YourContextType<T>>(YourContext);

  if (context === undefined) {
    // assert if context is available
    throw new Error('No context provided');
  }

  return context;
}

使用钩子

const { state, changeState } = useYourContext<{ name: string }>();

你会看到state和changeState都有类型。也许它不是你要找的100%，但对我来说已经足够了。查看@TheRubberDuck的解释
源代码：https://github.com/jaredpalmer/formik/blob/master/packages/formik/src/FormikContext.tsx