使用memoization函数来保存上一次选择器的结果，并在数据变化时重新计算选择器。

示例代码：

import { createSelector } from '@ngxs/store';

export class MyStateModel {
  data: string[];
  selectedId: number;
}

export class MyState {
  @Selector()
  static selectedData(state: MyStateModel) {
    return state.data.find(d => d.id === state.selectedId);
  }
  
  @Selector()
  static otherData(state: MyStateModel) {
    const selectedData = MyState.selectedData(state); // 通过调用选择器获取所选数据
    // 处理其他数据
    return processedData;
  }

  @Action(UpdateSelection)
  updateSelection(ctx: StateContext, { selectionId }: UpdateSelection) {
    const state = ctx.getState();
    if (state.selectedId !== selectionId) {
      ctx.patchState({ selectedId: selectionId });
      MyState.otherData.release(); // 释放先前的memoization缓存
    }
  }
}

export function memoize(fn: (arg: T) => U): (arg: T) => U {
  let lastArg: T;
  let lastResult: U;
  return arg => {
    if (arg === lastArg) {
      return lastResult;
    }
    lastArg = arg;
    lastResult = fn(arg);
    return lastResult;
  };
}

// 创建一个选择器的memoize包装器
function memoizeSelector(selector: (arg: T) => U) {
  const memoizedSelector = createSelector(selector);
  return memoize(memoizedSelector);
}

// 在组件中使用memoizeSelector
export class MyComponent {
  selectedData$ = memoizeSelector(MyState.selectedData);
  otherData$ = memoizeSelector(MyState.otherData);

  constructor(private store: Store) {}

  updateSelection(id: number) {
    this.store.dispatch(new UpdateSelection(id));
  }
}