protected override void HandleStatement(HandleContext context) { AssignmentStatement assignment = (AssignmentStatement)context.Statement; if (!CoversAssignment(assignment)) { return; } Method sourceConstructor = ExtractConstructor(assignment.Source); string variableName = IntrospectionUtility.GetVariableName(assignment.Target); bool fragmentTypeInferenceRequired = FirstParameterIsString(sourceConstructor); if (fragmentTypeInferenceRequired) { Fragment fragmentType = FirstOperandsFragmentType(assignment, context); context.StringBuilderFragmentTypeDefined[variableName] = true; context.SymbolTable.MakeSafe(variableName, fragmentType); } else { //context.StringBuilderFragmentTypeDefined[variableName] = false; context.SymbolTable.MakeSafe(variableName, Fragment.CreateUndefined()); } }
public async Task Mediate(TMessage message, IMessageContext messageContext) { var handleContext = new HandleContext(message, _cancellationToken); try { await messageContext.RunPreHandlers(handleContext); foreach (var handler in messageContext.Handlers) { await(Task) handler.Value.Handle(handleContext); } await messageContext.RunPostHandlers(handleContext); } catch (Exception e) { if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0) { throw; } handleContext.Exception = e; await messageContext.RunErrorHandlers(handleContext); } }
public void ArrayConstructIsParsed() { MockRepository mocks = new MockRepository(); IBlacklistManager blacklistManager = mocks.Stub <IBlacklistManager>(); Dictionary <string, bool> locallyInitializedArrays = new Dictionary <string, bool>(); BlockParserContext blockParserContext = new BlockParserContext( new ProblemPipeStub(), Fragment.CreateNamed("returnFragmentType"), new List <ReturnCondition>(), blacklistManager, delegate { }); ArrayConstructStatementHandler handler = new ArrayConstructStatementHandler(blockParserContext); Method sampleMethod = IntrospectionUtility.MethodFactory <ArrayConstructStatementHandlerSample> ("LocallyInitializedArray"); Block sampleBlock = (Block)sampleMethod.Body.Statements[0]; Statement sample = sampleBlock.Statements[1]; ISymbolTable symbolTable = mocks.Stub <ISymbolTable>(); HandleContext context = new HandleContext( sample, symbolTable, new List <IPreCondition>(), new List <string>(), new List <BlockAssignment>(), new List <int>(), locallyInitializedArrays, new Dictionary <string, bool>()); handler.Handle(context); bool locallyInitializedArrayAdded = locallyInitializedArrays.ContainsKey("local$2") && locallyInitializedArrays["local$2"] == false; Assert.That(locallyInitializedArrayAdded, Is.True); }
public void Handle_WrongStatementType_ThrowsException() { MockRepository mocks = new MockRepository(); IBlacklistManager blacklistManager = mocks.Stub <IBlacklistManager>(); BlockParserContext blockParserContext = new BlockParserContext( new ProblemPipeStub(), Fragment.CreateNamed("returnFragmentType"), new List <ReturnCondition>(), blacklistManager, delegate { }); StatementHandlerBase <AssignmentStatement> handler = new AssignmentStatementHandlerController(blockParserContext); Method sampleMethod = IntrospectionUtility.MethodFactory <StatementHandlerBaseSample> ("ContainsReturnStatement"); Block sampleBlock = (Block)sampleMethod.Body.Statements[1]; Statement sample = sampleBlock.Statements[0]; ISymbolTable symbolTable = mocks.Stub <ISymbolTable>(); HandleContext context = new HandleContext( sample, symbolTable, new List <IPreCondition>(), new List <string>(), new List <BlockAssignment>(), new List <int>(), new Dictionary <string, bool>(), new Dictionary <string, bool>()); handler.Handle(context); }
public WeightSettingsWindow(HandleContext windowContext) { this.windowContext = windowContext; this.absorbInputAroundWindow = true; this.closeOnClickedOutside = false; this.onlyOneOfTypeAllowed = true; switch (windowContext) { case HandleContext.GENERAL: windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeights"; windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeights"; break; case HandleContext.WORLD: windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsPerWorldGen"; windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsPerWorldGen"; break; case HandleContext.STARTING: windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsStartingPawns"; windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsStartingPawns"; break; case HandleContext.LOCAL: windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsLocal"; windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsLocal"; break; } windowHandles = ModSettingsHandler.allHandleReferences; EvaluateWhichDefsAreAdjusted(); }
public async Task BarHandleFooErrorsTest() { // arrange var configuration = new Dictionary <string, IHandlerBehavior> { { "Foo", new HandlerBehavior() }, { "Bar", new HandlerBehavior { Mode = HandleMode.OnError, } }, }; var barMock = new Mock <BarHandler>(); var context = new HandleContext <string>("It will fail"); barMock.Setup(b => b.Handle(context)).ReturnsAsync(new HandleResult()); _kernel.Bind <IHandler <string> >().To <FooHandler>().Named("Foo"); _kernel.Bind <IHandler <string> >().ToMethod(ctx => barMock.Object).Named("Bar"); _pipeline.Configure(configuration); // act var result = await _pipeline.Execute(context).ConfigureAwait(false); // assert result.Success.Should().BeFalse(); result.Errors.Should().HaveCount(1); barMock.Verify(b => b.HandleError(context)); }
public override void Handle(HandleContext context) { var p = context.Packet; if (p == null) { return; } Console.WriteLine("{0}({1})", p, p.GetType().Name); }
internal static void ResetHandle(ref Dictionary <string, float> handle, HandleContext context) { Dictionary <string, float> hcopy = new Dictionary <string, float>(handle); foreach (string key in hcopy.Keys) { handle[key] = -1.0f; } UpdateHandleReferencesInAllReferences(ref handle, context); }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement; if (!CoversAssignment (assignmentStatement)) return; var target = (Local) assignmentStatement.Target; context.ArrayFragmentTypeDefined[target.Name.Name] = false; context.AssignmentTargetVariables.Add (target.Name.Name); }
private void AddBlockAssignment(AssignmentStatement assignmentStatement, HandleContext context) { string targetSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Target); string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source); if (targetSymbol != null && sourceSymbol != null) { BlockAssignment blockAssignment = new BlockAssignment(sourceSymbol, targetSymbol); context.BlockAssignments.Add(blockAssignment); } }
public async IAsyncEnumerable <TMessageResult> Mediate(TMessage message, IMessageContext messageContext) { if (messageContext.Handlers.Count > 1) { throw new MultipleHandlerFoundException(typeof(TMessage)); } var handleContext = new HandleContext(message, _cancellationToken); var result = AsyncEnumerable.Empty <TMessageResult>(); try { await messageContext.RunPreHandlers(handleContext); var handler = messageContext.Handlers.Single().Value; result = (IAsyncEnumerable <TMessageResult>)handler !.Handle(handleContext); } catch (Exception e) { if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0) { throw; } handleContext.Exception = e; await messageContext.RunErrorHandlers(handleContext); } await foreach (var messageResult in result.WithCancellation(_cancellationToken)) { yield return(messageResult); } handleContext.MessageResult = result; try { await messageContext.RunPostHandlers(handleContext); } catch (Exception e) { if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0) { throw; } handleContext.Exception = e; await messageContext.RunErrorHandlers(handleContext); } }
public static async Task RunPreHandlers(this IMessageContext messageContext, HandleContext handleContext) { foreach (var preHandler in messageContext.IndirectPreHandlers) { await preHandler.Value.PreHandleAsync(handleContext); } foreach (var preHandler in messageContext.PreHandlers) { await preHandler.Value.PreHandleAsync(handleContext); } }
public static async Task RunErrorHandlers(this IMessageContext messageContext, HandleContext handleContext) { foreach (var errorHandler in messageContext.IndirectErrorHandlers) { await errorHandler.Value.HandleErrorAsync(handleContext); } foreach (var errorHandler in messageContext.ErrorHandlers) { await errorHandler.Value.HandleErrorAsync(handleContext); } }
private Fragment FirstOperandsFragmentType(AssignmentStatement assignment, HandleContext context) { Fragment fragmentType = Fragment.CreateEmpty(); Expression firstOperand = FirstOperand(assignment.Source); if (firstOperand != null) { ISymbolTable symbolTable = context.SymbolTable; fragmentType = symbolTable.InferFragmentType(firstOperand); } return(fragmentType); }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement; if (!CoversAssignment(assignmentStatement)) { return; } var target = (Local)assignmentStatement.Target; context.ArrayFragmentTypeDefined[target.Name.Name] = false; context.AssignmentTargetVariables.Add(target.Name.Name); }
public float GrabWeightReference(string race, HandleContext context, bool returnNegative = false) { string fullID = ModSettingsHandler.GetRaceSettingWeightID(context, race); if (fullID != null) { SettingHandle <float> handle = windowHandles.FirstOrFallback(h => h.Name == fullID, null); if (handle != null) { if ((prevAdjustedRaces[race] && windowContext == context) || (handle.Value < 0.0f && windowContext != context)) { if (returnNegative) { return(-1.0f); } switch (context) { case HandleContext.STARTING: return(GrabWeightReference(race, HandleContext.WORLD)); case HandleContext.WORLD: case HandleContext.LOCAL: //This is performed so that it can also return the human's race setting return(GrabWeightReference(race, HandleContext.GENERAL)); case HandleContext.GENERAL: KeyValuePair <string, RaceDiversificationPool> data = racesDiversified.FirstOrFallback(r => r.Key == race); if (data.Key != null) { return(data.Value.flatGenerationWeight); } break; } } //This does not display negatives (checkbox will check for that instead) if (handle.Value >= 0.0f) { return(handle.Value); } else { return(0.0f); } } } return(0.0f); }
protected override void HandleStatement(HandleContext context) { IStatementHandler selectedHandler; Func <AssignmentStatementHandlerBase, bool> handlerFilter = handler => handler.Covers(context.Statement); if (_specificHandlers.Any(handlerFilter)) { selectedHandler = _specificHandlers.Single(handlerFilter); } else { selectedHandler = _defaultAssignmentStatementHandler; } selectedHandler.Handle(context); }
public override async void Handle(HandleContext context) { HttpRequest request = context.Packet as HttpRequest; if (request == null) { return; } HttpResponse response = Handle(request); await context.Session.SendAsync(response); await context.Session.Close(); }
private void CheckAssignment(AssignmentStatement assignmentStatement, string targetName, HandleContext context) { ISymbolTable symbolTable = context.SymbolTable; Fragment targetFragmentType = symbolTable.GetFragmentType (targetName); Fragment sourceFragmentType = symbolTable.InferFragmentType (assignmentStatement.Source); if (targetFragmentType != sourceFragmentType) { symbolTable.MakeUnsafe (targetName); } else { SetPreConditionForIndexerObject (assignmentStatement, targetName, sourceFragmentType, context); } }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement; if(!CoversAssignment(assignmentStatement)) return; Method assignedMethod = GetAssignedDelegateMethod (assignmentStatement); DelegateNode sourceDelegateType = (DelegateNode) assignmentStatement.Source.Type; Fragment returnFragment = GetDelegateTypesReturnFragment (sourceDelegateType); ISymbolTable environment = GetDelegatesEnvironment (sourceDelegateType); IMethodGraphAnalyzer methodParser = new MethodGraphAnalyzer (_blockParserContext.ProblemPipe); IMethodGraphBuilder methodGraphBuilder = new MethodGraphBuilder (assignedMethod, _blockParserContext.BlacklistManager, _blockParserContext.ProblemPipe, returnFragment); IInitialSymbolTableBuilder parameterSymbolTableBuilder = new EmbeddedInitialSymbolTableBuilder (assignedMethod, _blockParserContext.BlacklistManager, environment); methodParser.Parse (methodGraphBuilder, parameterSymbolTableBuilder); }
internal static string GetRaceSettingWeightID(HandleContext context, string race) { switch (context) { case HandleContext.GENERAL: return("flatGenerationWeight_" + race); case HandleContext.WORLD: return("flatGenerationWeightPerWorld_" + race); case HandleContext.STARTING: return("flatGenerationWeightStartingPawns_" + race); case HandleContext.LOCAL: return("flatGenerationWeightLocal_" + race); } return(null); }
private void InferArrayFragment(AssignmentStatement assignmentStatement, string targetName, HandleContext context) { ISymbolTable symbolTable = context.SymbolTable; Fragment targetFragmentType = symbolTable.InferFragmentType (assignmentStatement.Source); if (context.ArrayFragmentTypeDefined[targetName] == false) { symbolTable.MakeSafe(targetName, targetFragmentType); context.ArrayFragmentTypeDefined[targetName] = true; } else if (symbolTable.GetFragmentType(targetName) == Fragment.CreateLiteral()) { symbolTable.MakeSafe(targetName, targetFragmentType); } else if (symbolTable.GetFragmentType(targetName) != targetFragmentType && targetFragmentType != Fragment.CreateLiteral()) { symbolTable.MakeUnsafe(targetName); } }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement; if(!CoversAssignment(assignmentStatement)) return; Indexer targetIndexer = (Indexer) assignmentStatement.Target; string targetName = IntrospectionUtility.GetVariableName (targetIndexer.Object); if (context.ArrayFragmentTypeDefined.ContainsKey (targetName)) { InferArrayFragment(assignmentStatement, targetName, context); } else { CheckAssignment(assignmentStatement, targetName, context); } _blockParserContext.Inspect (assignmentStatement.Source); }
private void OnMessageReceived(object sender, DLB.EventBus.Transport.Messages.TransportMessage e) { var handler = _subscribers.FirstOrDefault(p => p.Topic == e.Topic); string jsonStr = Encoding.UTF8.GetString(e.Body); if (!string.IsNullOrEmpty(jsonStr)) { // Message received context var context = new HandleContext(_consumerClient, e.Headers); var method = handler.GetType().GetMethod(HandleAsyncMethod); // Get only dynamic parameter, type of IntegrationEventData var type = method.GetParameters().FirstOrDefault().ParameterType; var data = JsonConvert.DeserializeObject(jsonStr, type); object[] parametersArray = new object[] { data, context, this }; method.Invoke(handler, parametersArray); } }
private void Inspect(Block methodBodyBlock) { foreach (Statement statement in methodBodyBlock.Statements) { if (_statementHandlers.ContainsKey(statement.GetType())) { HandleContext context = new HandleContext( statement, _symbolTableParser, _preConditions, _assignmentTargetVariables, _blockAssignments, _successors, _locallyInitializedArrays, _stringBuilderFragmentTypesDefined); _statementHandlers[statement.GetType()].Handle(context); } } }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement; if (!CoversAssignment(assignmentStatement)) { return; } Method assignedMethod = GetAssignedDelegateMethod(assignmentStatement); DelegateNode sourceDelegateType = (DelegateNode)assignmentStatement.Source.Type; Fragment returnFragment = GetDelegateTypesReturnFragment(sourceDelegateType); ISymbolTable environment = GetDelegatesEnvironment(sourceDelegateType); IMethodGraphAnalyzer methodParser = new MethodGraphAnalyzer(_blockParserContext.ProblemPipe); IMethodGraphBuilder methodGraphBuilder = new MethodGraphBuilder(assignedMethod, _blockParserContext.BlacklistManager, _blockParserContext.ProblemPipe, returnFragment); IInitialSymbolTableBuilder parameterSymbolTableBuilder = new EmbeddedInitialSymbolTableBuilder(assignedMethod, _blockParserContext.BlacklistManager, environment); methodParser.Parse(methodGraphBuilder, parameterSymbolTableBuilder); }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignment = (AssignmentStatement) context.Statement; if(!CoversAssignment(assignment)) return; Method sourceConstructor = ExtractConstructor (assignment.Source); string variableName = IntrospectionUtility.GetVariableName (assignment.Target); bool fragmentTypeInferenceRequired = FirstParameterIsString (sourceConstructor); if (fragmentTypeInferenceRequired) { Fragment fragmentType = FirstOperandsFragmentType(assignment, context); context.StringBuilderFragmentTypeDefined[variableName] = true; context.SymbolTable.MakeSafe (variableName, fragmentType); } else { //context.StringBuilderFragmentTypeDefined[variableName] = false; context.SymbolTable.MakeSafe (variableName, Fragment.CreateUndefined()); } }
public void HandleStatement_InitializationWithEmptyConstructor_VariableFragmentTypeIsNull() { Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("InitializationWithEmptyConstructor"); Block sampleBlock = (Block)sampleMethod.Body.Statements[0]; Statement sample = sampleBlock.Statements[1]; HandleContext context = new HandleContext( sample, _symbolTable, new List <IPreCondition>(), new List <string>(), new List <BlockAssignment>(), new List <int>(), new Dictionary <string, bool>(), _stringBuilderFragmentTypesDefined); _handler.Handle(context); bool variableUndefined = _symbolTable.GetFragmentType("local$0").Undefined; Assert.That(variableUndefined, Is.True); }
public void HandleStatement_NonStringBuilderAssignment_VariableNotMapped() { Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("NonStringBuilderAssignment"); Block sampleBlock = (Block)sampleMethod.Body.Statements[0]; Statement sample = sampleBlock.Statements[1]; HandleContext context = new HandleContext( sample, _symbolTable, new List <IPreCondition>(), new List <string>(), new List <BlockAssignment>(), new List <int>(), new Dictionary <string, bool>(), _stringBuilderFragmentTypesDefined); _handler.Handle(context); bool variableAdded = _stringBuilderFragmentTypesDefined.ContainsKey("local$0"); Assert.That(variableAdded, Is.False); }
public void HandleStatement_InitializationWithFragmentAndInts_VariableFragmentTypeIsFragment() { Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("InitializationWithFragmentAndInts"); Block sampleBlock = (Block)sampleMethod.Body.Statements[0]; Statement sample = sampleBlock.Statements[1]; HandleContext context = new HandleContext( sample, _symbolTable, new List <IPreCondition>(), new List <string>(), new List <BlockAssignment>(), new List <int>(), new Dictionary <string, bool>(), _stringBuilderFragmentTypesDefined); _handler.Handle(context); bool symbolTableEntryCorrect = _symbolTable.GetFragmentType("local$0") == Fragment.CreateNamed("StringBuilderFragment"); Assert.That(symbolTableEntryCorrect, Is.True); }
private async Task OnMessageReceivedAsync(object sender, DLB.EventBus.Transport.Messages.TransportMessage e) { using (var scope = _serviceScopeFactory.CreateScope()) { var subscribers = scope.ServiceProvider.GetService <IEnumerable <ISubscriber> >(); string jsonStr = Encoding.UTF8.GetString(e.Body); var handlerList = subscribers.Where(p => p.Topic == e.Topic); if (!string.IsNullOrEmpty(jsonStr) && handlerList != null && handlerList.Any()) { // Message received context var context = new HandleContext(_consumerClient, e); foreach (var handler in handlerList) { // Get only dynamic parameter, type of IntegrationEventData var method = handler.GetType().GetMethod(HandleAsyncMethod); var type = method.GetParameters().FirstOrDefault().ParameterType; var headerType = e.Headers[Messages.Headers.Type]; if (headerType == type.Name) { // If no throw exception we found a valid handler var data = JsonConvert.DeserializeObject(jsonStr, type, this._options.JsonSerializerSettings); object[] parametersArray = new object[] { data, context, this }; var task = (Task)method.Invoke(handler, parametersArray); await task.ConfigureAwait(false); break; } } } } }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement; string targetSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Target); context.AssignmentTargetVariables.Add(targetSymbol); string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source); bool localSourceVariableNotAssignedInsideCurrentBlock = sourceSymbol != null && !context.AssignmentTargetVariables.Contains(sourceSymbol) && !IntrospectionUtility.IsField(assignmentStatement.Source); bool targetIsField = IntrospectionUtility.IsField(assignmentStatement.Target); if (localSourceVariableNotAssignedInsideCurrentBlock) { if (targetIsField) { AddAssignmentPreCondition(assignmentStatement, context); } else { AddBlockAssignment(assignmentStatement, context); } } else { if (targetIsField) { ValidateAssignmentOnField(assignmentStatement, context); } else { context.SymbolTable.InferSafeness(targetSymbol, assignmentStatement.Source); } } _blockParserContext.Inspect(assignmentStatement.Source); }
protected override void HandleStatement(HandleContext context) { AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement; if (!CoversAssignment(assignmentStatement)) { return; } Indexer targetIndexer = (Indexer)assignmentStatement.Target; string targetName = IntrospectionUtility.GetVariableName(targetIndexer.Object); if (context.ArrayFragmentTypeDefined.ContainsKey(targetName)) { InferArrayFragment(assignmentStatement, targetName, context); } else { CheckAssignment(assignmentStatement, targetName, context); } _blockParserContext.Inspect(assignmentStatement.Source); }
public async Task <TMessageResult> Mediate(TMessage message, IMessageContext messageContext) { if (messageContext.Handlers.Count > 1) { throw new MultipleHandlerFoundException(typeof(TMessage)); } var handleContext = new HandleContext(message, _cancellationToken); TMessageResult result = default; try { await messageContext.RunPreHandlers(handleContext); var handler = messageContext.Handlers.Single().Value; result = await(Task <TMessageResult>) handler !.Handle(handleContext); handleContext.MessageResult = result; await messageContext.RunPostHandlers(handleContext); } catch (Exception e) { if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0) { throw; } handleContext.Exception = e; await messageContext.RunErrorHandlers(handleContext); } return(result); }
private void SetPreConditionForIndexerObject( AssignmentStatement assignmentStatement, string targetName, Fragment sourceFragmentType, HandleContext context) { if (targetName != null) { ProblemMetadata problemMetadata = new ProblemMetadata ( assignmentStatement.UniqueKey, assignmentStatement.SourceContext, sourceFragmentType, Fragment.CreateNamed ("??")); var preCondition = new EqualityPreCondition (targetName, sourceFragmentType, problemMetadata); context.PreConditions.Add (preCondition); } }
private Fragment FirstOperandsFragmentType(AssignmentStatement assignment, HandleContext context) { Fragment fragmentType = Fragment.CreateEmpty(); Expression firstOperand = FirstOperand (assignment.Source); if (firstOperand != null) { ISymbolTable symbolTable = context.SymbolTable; fragmentType = symbolTable.InferFragmentType(firstOperand); } return fragmentType; }
private void SetPreConditionForIndexerObject( AssignmentStatement assignmentStatement, string targetName, Fragment sourceFragmentType, HandleContext context) { if (targetName != null) { ProblemMetadata problemMetadata = new ProblemMetadata( assignmentStatement.UniqueKey, assignmentStatement.SourceContext, sourceFragmentType, Fragment.CreateNamed("??")); var preCondition = new EqualityPreCondition(targetName, sourceFragmentType, problemMetadata); context.PreConditions.Add(preCondition); } }
public virtual void Process(CronusMessage message) { var context = new HandleContext(message, handlerType); handlerWorkflow.Run(context); }