C# (CSharp) IIndexedState示例

示例#1

        public SportsTeamGrain(
#if USE_TRANSACTIONS
            [TransactionalIndexedState("stateName", GrainStoreName)]
#else
            [NonFaultTolerantWorkflowIndexedState("stateName", GrainStoreName)]
#endif
            IIndexedState <SportsTeamState> indexedState) => this.indexedState = indexedState;

示例#2

文件： TestMultiIndexGrainBase.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

        internal TestMultiIndexGrainBase(Type grainClassType, IIndexedState <TGrainState> indexedState)
        {
            this.IndexedState = indexedState;

            var grainInterfaceTypes = ApplicationPartsIndexableGrainLoader.EnumerateIndexedInterfacesForAGrainClassType(grainClassType).ToArray();

            Assert.Single(grainInterfaceTypes);
            var propertiesType = grainInterfaceTypes[0].propertiesType;

            Assert.True(propertiesType.IsClass);

            bool isIndexed(string propertyName)
            {
                var propInfo = propertiesType.GetProperty(propertyName);

                return(propInfo.GetCustomAttributes <IndexAttribute>(inherit: false).Any());
            }

            this.IsUniqueIntIndexed       = isIndexed(nameof(ITestMultiIndexProperties.UniqueInt));
            this.IsUniqueStringIndexed    = isIndexed(nameof(ITestMultiIndexProperties.UniqueString));
            this.IsNonUniqueIntIndexed    = isIndexed(nameof(ITestMultiIndexProperties.NonUniqueInt));
            this.IsNonUniqueStringIndexed = isIndexed(nameof(ITestMultiIndexProperties.NonUniqueString));

            Assert.True(this.IsUniqueIntIndexed || this.IsUniqueStringIndexed || this.IsNonUniqueIntIndexed || this.IsNonUniqueStringIndexed);
        }

示例#3

文件： MultiIndex_TI_EG_Runner.cs 项目： sergeybykov/Orleans.Indexing-prep

 public TXN_Grain_UIUSNINS_TI_EG_PK(
     [TransactionalIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#4

文件： MultiInterface_XI_EG_Runner.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

 public NFT_Grain_Employee_XI_EG_PK(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <EmployeeGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#5

文件： IndexUtils.cs 项目： sergeybykov/Orleans.Indexing-prep

 public static Task PerformUpdate <TGrainState>(this IIndexedState <TGrainState> indexedState, Action <TGrainState> updateAction)
     where TGrainState : class, new()
 => indexedState.PerformUpdate(state => { updateAction(state); return(true); });

示例#6

 public NFT_Grain_UIUSNINS_XI_LZ_PK(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#7

 public NFT_Grain_UIUSNINS_DSMI_LZ_PK(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingTestConstants.CosmosDBGrainStorage)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#8

文件： IndexingGrainTransactional_PK.cs 项目： zhonli/OrleansV2.Fork.Indexing

 public IndexingGrainTransactional_PK(
     [TransactionalIndexedState(IndexUtils.IndexedGrainStateName)]
     IIndexedState <IndexingState> indexedState)
     : base(indexedState)
 {
 }

示例#9

文件： Player3Grain.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

 public Player3Grain(
     [FaultTolerantWorkflowIndexedState(IndexingTestConstants.GrainStore)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#10

 public FT_Grain_UIUSNINS_TI_LZ_SB(
     [FaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#11

 public TestMultiIndexGrainTransactional(IIndexedState <TGrainState> indexedState) : base(indexedState)
     => Debug.Assert(this.GetType().GetConsistencyScheme() == ConsistencyScheme.Transactional);

示例#12

 public TestMultiIndexGrainFaultTolerant(IIndexedState <TGrainState> indexedState) : base(indexedState)
     => Debug.Assert(this.GetType().GetConsistencyScheme() == ConsistencyScheme.FaultTolerantWorkflow);

示例#13

 public PlayerGrain(IIndexedState <TGrainState> indexedState) => this.indexedState = indexedState;

示例#14

 public TestMultiIndexGrain(IIndexedState <TGrainState> indexedState) =>
 this.testBase = new TestMultiIndexGrainBase <TGrainState>(this.GetType(), indexedState);

示例#15

 public GrainShared2(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <GrainState> indexedState)
     : base(indexedState)
 {
 }

示例#16

 protected TestEmployeeGrain(IIndexedState <TGrainState> indexedState) => this.indexedState = indexedState;

示例#17

文件： MultiIndex_DSMI_EG_Runner.cs 项目： sergeybykov/Orleans.Indexing-prep

 public TXN_Grain_UIUSNINS_DSMI_EG_PK(
     [TransactionalIndexedState(IndexingConstants.IndexedGrainStateName, IndexingTestConstants.CosmosDBGrainStorage)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#18

文件： Player_FT_TI_LZ_PK.cs 项目： sergeybykov/Orleans.Indexing-prep

 public Player_FT_TI_LZ_PK(
     [FaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingTestConstants.GrainStore)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#19

文件： IndexingGrainWorkflowFT_PK.cs 项目： zhonli/OrleansV2.Fork.Indexing

 public IndexingGrainWorkflowFT_PK(
     [FaultTolerantWorkflowIndexedState(IndexUtils.IndexedGrainStateName)]
     IIndexedState <IndexingState> indexedState)
     : base(indexedState)
 {
 }

示例#20

文件： MultiIndex_DSMI_LZ_Runner.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

 public FT_Grain_UIUSNINS_DSMI_LZ_SB(
     [FaultTolerantWorkflowIndexedState(IndexingTestConstants.CosmosDBGrainStorage)]
     IIndexedState <TestMultiIndexState> indexedState)
     : base(indexedState)
 {
 }

示例#21

 public TXN_Grain_Employee_TI_EG_PK(
     [TransactionalIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <EmployeeGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#22

文件： SportsTeamGrain.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

 public SportsTeamGrain(
     [NonFaultTolerantWorkflowIndexedState(GrainStoreName)]
     IIndexedState <SportsTeamState> indexedState) => this.indexedState = indexedState;

示例#23

文件： IndexUtils.cs 项目： sergeybykov/Orleans.Indexing-prep

 public static Task PerformRead <TGrainState>(this IIndexedState <TGrainState> indexedState)
     where TGrainState : class, new()
 => indexedState.PerformRead(_ => true);

示例#24

 public Player_NFT_AI_EG_PSPS(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#25

文件： Player5GrainNonFaultTolerant.cs 项目： TedHartMS/OrleansV2.Fork.Indexing

 public Player5GrainNonFaultTolerant(
     [NonFaultTolerantWorkflowIndexedState(IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#26

 public TransactionalPlayerGrain(
     [TransactionalIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#27

 public FT_Grain_Employee_TI_LZ_SB(
     [FaultTolerantWorkflowIndexedState(IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <EmployeeGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#28

 public GrainBase(IIndexedState <GrainState> indexedState) => this.indexedState = indexedState;

示例#29

文件： Player_FT_TI_LZ_SB.cs 项目： sergeybykov/Orleans.Indexing-prep

 public Player_FT_TI_LZ_SB(
     [FaultTolerantWorkflowIndexedState(IndexingConstants.IndexedGrainStateName, IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME)]
     IIndexedState <PlayerGrainState> indexedState)
     : base(indexedState)
 {
 }

示例#30

文件： IndexingTestUtils.cs 项目： sergeybykov/Orleans.Indexing-prep

        internal static async Task SetPropertyAndWriteStateAsync <TGrainState>(Action <TGrainState> setterAction, IIndexedState <TGrainState> indexedState, bool retry)
            where TGrainState : class, new()
        {
            const int MaxRetries = 10;
            int       retries    = 0;

            while (true)
            {
                try
                {
                    await indexedState.PerformUpdate(setterAction);

                    return;
                }
                catch (Exception) when(retry && retries < MaxRetries)
                {
                    ++retries;
                    await indexedState.PerformRead();
                }
            }
        }