将查询表达式转换为Linq C#

转换此处找到的查询表达式时遇到问题： 转换为linq查询。简单地说，目标是如果两个工作流同时被触发，只让其中一个按最新工作流排序。当前，我的linq版本有时会取消工作流，即使它是唯一正在运行的工作流。我知道我需要以某种方式利用输入参数（告诉它要与哪个工作流进行比较），而且我确信可能会有更多的问题。非常感谢您的帮助

        [Input("Current workflow")]
        [ReferenceTarget("workflow")]
        public InArgument<EntityReference> workflowReferenceInput { get; set; } 
        [Output("Is first workflow")]
    public OutArgument<Boolean> isFirstWorkflow { get; set; }

    protected override void Execute(CodeActivityContext executionContext)
    {
        ITracingService tracer = executionContext.GetExtension<ITracingService>();
        IWorkflowContext context = executionContext.GetExtension<IWorkflowContext>();
        IOrganizationServiceFactory serviceFactory = executionContext.GetExtension<IOrganizationServiceFactory>();
        IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

        try
        {
            Entity entity = (Entity)context.InputParameters["Target"];
            isFirstWorkflow.Set(executionContext, false);

            var wfReference = workflowReferenceInput.Get(executionContext);
            var wfEntity = service.Retrieve("workflow", wfReference.Id, new ColumnSet ( "name" ));

            ConditionExpression ce1 = new ConditionExpression();
            ce1.AttributeName = "statuscode";
            ce1.Operator = ConditionOperator.In;
            ce1.Values.Add(0);
            ce1.Values.Add(10);
            ce1.Values.Add(20);
            ce1.Values.Add(21);
            ce1.Values.Add(22);
            FilterExpression fe1 = new FilterExpression();
            fe1.Conditions.Add(ce1);

            QueryExpression qe = new QueryExpression();
            qe.EntityName = AsyncOperation.EntityLogicalName;
            qe.ColumnSet = new ColumnSet();
            qe.Criteria = new FilterExpression();
            qe.Criteria.AddFilter(fe1);
            var childFilter = qe.Criteria.AddFilter(LogicalOperator.And);
            childFilter.AddCondition("operationtype", ConditionOperator.Equal, 10);
            childFilter.AddCondition("name", ConditionOperator.Equal, wfEntity["name"]);

            LinkEntity link = new LinkEntity
            {
                LinkFromEntityName = AsyncOperation.EntityLogicalName,
                LinkToEntityName = Quote.EntityLogicalName,
                LinkFromAttributeName = "regardingobjectid",
                LinkToAttributeName = "quoteid"
            };
            link.LinkCriteria.AddCondition("quoteid", ConditionOperator.Equal, context.PrimaryEntityId.ToString());

            DataCollection<Entity> result = service.RetrieveMultiple(qe).Entities;

            var list = result.ToList().OrderBy(c => c.Id);
            for (var i = 0; i < list.Count(); i++)
            {
                var item = list.ElementAt(i);
                if(item.Id == context.OperationId && i == 0)
                {
                    isFirstWorkflow.Set(executionContext, true);
                }
            }

        }
        catch (Exception e)
        {
            throw new InvalidPluginExecutionException(e.Message);
        }
    }

[输入（“当前工作流”）]
[参考目标（“工作流”）]
公共InArgument workflowReferenceInput{get；set；}
[输出（“是第一个工作流”）]
public OutArgument isFirstWorkflow{get；set；}
受保护的覆盖无效执行（CodeActivityContext executionContext）
{
ITracingService tracer=executionContext.GetExtension（）；
IWorkflowContext=executionContext.GetExtension（）；
IOOrganizationServiceFactory服务工厂=executionContext.GetExtension（）；
IOOrganizationService=serviceFactory.CreateOrganizationService（context.UserId）；
尝试
{
实体=（实体）上下文。输入参数[“目标”]；
isFirstWorkflow.Set（executionContext，false）；
var wfReference=workflowReferenceInput.Get（executionContext）；
var wfEntity=service.Retrieve（“工作流”，wffreference.Id，新列集（“名称”）；
ConditionExpression ce1=新的ConditionExpression（）；
ce1.AttributeName=“状态代码”；
ce1.Operator=ConditionOperator.In；
ce1.值。添加（0）；
ce1.价值。增加（10）；
ce1.价值。增加（20）；
ce1.价值。增加（21）；
ce1.价值增加（22）；
FilterExpression fe1=新的FilterExpression（）；
fe1.条件。添加（ce1）；
QueryExpression qe=新的QueryExpression（）；
qe.EntityName=AsyncOperation.EntityLogicalName；
qe.ColumnSet=新ColumnSet（）；
qe.Criteria=newFilterExpression（）；
qe.标准.添加过滤器（fe1）；
var childFilter=qe.Criteria.AddFilter（LogicalOperator.And）；
AddCondition（“operationtype”，ConditionOperator.Equal，10）；
AddCondition（“name”，ConditionOperator.Equal，wfEntity[“name”]）；
LinkEntity link=新的LinkEntity
{
LinkFromEntityName=AsyncOperation.EntityLogicalName，
LinkToEntityName=Quote.EntityLogicalName，
LinkFromAttributeName=“关于对象ID”，
LinkToAttributeName=“quoteid”
};
link.LinkCriteria.AddCondition（“quoteid”，ConditionOperator.Equal，context.PrimaryEntityId.ToString（））；
数据收集结果=service.RetrieveMultiple（qe）.Entities；
var list=result.ToList（）.OrderBy（c=>c.Id）；
对于（var i=0；i

为此：

 public class WorkflowChecker: CodeActivity
{
    [Input("Current workflow")]
    [ReferenceTarget("workflow")]
    public InArgument<EntityReference> workflowReferenceInput { get; set; }

    [Output("Is first workflow")] public OutArgument<Boolean> isFirstWorkflow { get; set; }

    protected override void Execute(CodeActivityContext executionContext)
    {
        IWorkflowContext context = executionContext.GetExtension<IWorkflowContext>();

        try
        {                
            var ok = WorkflowChecker(context.PrimaryEntityId, context.OperationId);

            isFirstWorkflow.Set(executionContext, ok);
        }
        catch (Exception e)
        {
            throw new InvalidPluginExecutionException(e.Message);
        }

    }
}

公共类工作流检查器：CodeActivity
{
[输入（“当前工作流”）]
[参考目标（“工作流”）]
公共InArgument workflowReferenceInput{get；set；}
[Output（“Is first workflow”）]公共输出参数isFirstWorkflow{get；set；}
受保护的覆盖无效执行（CodeActivityContext executionContext）
{
IWorkflowContext=executionContext.GetExtension（）；
尝试
{                
var ok=WorkflowChecker（context.PrimaryEntityId，context.OperationId）；
isFirstWorkflow.Set（executionContext，ok）；
}
捕获（例外e）
{
抛出新的InvalidPlugineExecutionException（e.Message）；
}
}
}

这要求：

 public static bool WorkflowChecker(Guid workflowContextId,
        Guid asyncOperationId)
    {
        var someReturnValue = false;
        var listOfWorkflowIds = new List<Guid>();

        try
        {
            var query = from async in AsyncOperationSet
                join b in BSet on async.RegardingObjectId.Id equals b.Id                        
                where b.Id.Equals(workflowContextId)
                      && (async.StateCode.Equals(0)
                          || async.StateCode.Equals(1)
                          || async.StateCode.Equals(2))
                select new {async.AsyncOperationId};
            foreach (var x in query)
            {
                if (x.AsyncOperationId != Guid.Empty)
                {
                    listOfWorkflowIds.Add(x.AsyncOperationId.Value);
                }
            }

            listOfWorkflowIds.Sort();

            if (listOfWorkflowIds.First() == asyncOperationId)
            {
                someReturnValue = true;
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Error in Workflow Checker: " + e);
        }


        return someReturnValue;
    }

公共静态bool WorkflowChecker（Guid workflowContextId，
Guid（异步操作ID）
{
var-someReturnValue=false；
var listOfWorkflowIds=新列表（）；
尝试
{
var query=来自AsyncOperationSet中的async
将b加入async.RegardingObjectId等于b.Id的b集
其中b.Id.Equals（workflowContextId）
&&（async.StateCode.Equals（0）
||async.StateCode.Equals（1）
||async.StateCode.Equals（2））
选择新的{async.AsyncOperationId}；
foreach（查询中的变量x）
{
if（x.AsyncOperationId！=Guid.Empty）
{
添加（x.AsyncOperationId.Value）；
}
}
listofWorkflowId.Sort（）；
if（listofWorkflowId.First（）==asyncOperationId）
{
someReturnValue=true；
}
}
捕获（例外e）
{
Console.WriteLine（“工作流检查器中的错误：+e”）；
}
返回返回值；
}

我已将以下行添加到工作流库中，然后将参数传递到调用中以按名称进行比较，到目前为止，它似乎工作正常：

var wfReference = workflowReferenceInput.Get(executionContext);
var wfEntity = service.Retrieve("workflow", wfReference.Id, new ColumnSet("name"));
var test =  wfEntity["name"];