Question

我有一种可再生的方法,即建立一个资源及其相关资源的类似树木的结构。

对于我与我一道工作的每一资源,我还要在一组成员名单内加一,我核对每个空缺,以确保我们不会明确地依靠相互依赖的资源。

每次我第一次提出这种休养方法时,我都需要清楚地列出该类成员名单。

此时,我有适当方法,在呼吁采用补习方法之间可以呼吁这样做。

我现在要删除这一方法,并每次自动重新编制清单。

目前,我可以找到两个办法解决这一问题:

Test whether the calling method is the same as the currently executing method and if not, reset the list
Get rid of the recursion and queue items instead, dequeueing and enqueueing as we go. At the end of the method call I can reset the list.

www.un.org/Depts/DGACM/index_spanish.htm 如何解决这一问题? 你们会采取什么办法?

我的法典目前如何看待:

public class GetAllRelatedResourcesByParentGuidQuery : IGetAllRelatedResourcesByParentGuidQuery
    {
        private readonly IList<Guid> _itemsCheckedForRelations = new List<Guid>();

        public IEnumerable<IDependency> Invoke(Guid parentCiId, 
                                                  IResoucesByIdQuery getResources)
        {
            if (!_itemsCheckedForRelations.Contains(parentCiId))
            {
                var relatedResources = getResources.Invoke(parentCiId);

                _itemsCheckedForRelations.Add(parentCiId);

                if (relatedResources.Count() > 0)
                {
                    foreach (var relatedResource in relatedResources)
                    {
                        relatedResource.Resource.DependentResources = Invoke(
                                                         relatedResource.Resource.Id, 
                                                         getResources);

                        yield return relatedResource;
                    }
                }
            }
        }

        public void ResetCheckedItemsCollection()
        {
            _itemsCheckedForRelations.Clear();
        }
    }

Answer 1

我将采用public方法,进行制作,但使recursive方法不谨慎,并将其作为参数。

public List<string> DoSomething(int input)
{
    List<string> results = new List<string>();
    DoSomethingImpl(input, results);
    return results;
}

private void DoSomethingImpl(int input, List<T> results)
{
    // For example...
    if (input == 0)
    {
        return results;
    }
    results.Add("Foo");
    DoSomethingImpl(input - 1, results);        
}

Answer 2

Just make a method calling an inner method like this:

public class GetAllRelatedResourcesByParentGuidQuery : IGetAllRelatedResourcesByParentGuidQuery 
{ 
        private readonly IList<Guid> _itemsCheckedForRelations = new List<Guid>(); 

        public IEnumerable<IDependency> Invoke(Guid parentCiId,  
                                                  IResoucesByIdQuery getResources) 
        {
            Reset();
            return InternalInvoke(parentCiID, getResources);
        }

        private IEnumerable<IDependency> InternalInvoke(Guid parentCiId,  
                                                  IResoucesByIdQuery getResources) 
        {
             //actual implementation, when going recursive, call this internal method
        }
}

Answer 3

It seems to me that the List shouldn t be a class member but a parameter for the method you call... any direct call happens with null for this parameter (could even be a default!)... the method allocates the List in that case and on the recursive calls it just passes the allocated List...

Answer 4

您可以尝试利用回传的伊斯兰教表达方式:

public class GetAllRelatedResourcesByParentGuidQuery :
                    IGetAllRelatedResourcesByParentGuidQuery
{
    public IEnumerable<IDependency> Invoke(
            Guid parentCiId,
            IResoucesByIdQuery getResources)
    {
        var checkedItems = new List<Guid>();
        Func<Guid, IResoucesByIdQuery, IEnumerable<IDependency>> invoke = null;
        invoke = (pcid, gr) =>
        {
            if (!checkedItems.Contains(pcid))
            {
                checkedItems.Add(pcid);
                var drs = gr.Invoke(pcid).ToArray();
                foreach (var relatedResource in drs)
                {
                    relatedResource
                        .Resource
                        .DependentResources =
                            invoke(relatedResource.Resource.Id, gr);
                }
                return drs;
            }
            return Enumerable.Empty<IDependency>();
        };
    }
}

采用这种办法,可以同时发出多次呼吁,而不必有任何特别逻辑来澄清名单。

友情链接