C# Bag.Count方法代码示例

        /// <summary>
        /// Removes from the propnet all components that are discovered through type
        /// inference to only ever be true or false, replacing them with their values
        /// appropriately. This method may remove base and input propositions that are
        /// shown to be always false (or, in the case of base propositions, those that
        /// are always true).
        /// </summary>
        /// <param name="pn"></param>
        /// <param name="basesTrueByInit">The set of base propositions that are true on the first turn of the game.</param>
        public void RemoveUnreachableBasesAndInputs(PropNet pn, HashSet<IProposition> basesTrueByInit)
        {
            //If this doesn't contain a component, that's the equivalent of Type.NEITHER
            var reachability = new Dictionary<IComponent, Type>();
            //Keep track of the number of true inputs to AND gates and false inputs to
            //OR gates.
            var numTrueInputs = new Bag<IComponent>();
            var numFalseInputs = new Bag<IComponent>();
            var toAdd = new Stack<Tuple<IComponent, TypeCode>>();

            //It's easier here if we get just the one-way version of the map
            var legalsToInputs = new Dictionary<IProposition, IProposition>();
            foreach (IProposition legalProp in pn.LegalPropositions.Values.SelectMany(v => v))
            {
                IProposition inputProp = pn.LegalInputMap[legalProp];
                if (inputProp != null)
                    legalsToInputs[legalProp] = inputProp;
            }

            //All constants have their values
            foreach (IComponent c in pn.Components) //ConcurrencyUtils.checkForInterruption();
                if (c is IConstant)
                    toAdd.Push(c.Value ? Tuple.Create(c, TypeCode.True) : Tuple.Create(c, TypeCode.False));

            //Every input can be false (we assume that no player will have just one move allowed all game)
            foreach (IProposition p in pn.InputPropositions.Values)
                toAdd.Push(Tuple.Create((IComponent)p, TypeCode.False));

            //Every base with "init" can be true, every base without "init" can be false
            foreach (IProposition baseProp in pn.BasePropositions.Values)
                toAdd.Push(basesTrueByInit.Contains(baseProp)
                    ? Tuple.Create((IComponent)baseProp, TypeCode.True)
                    : Tuple.Create((IComponent)baseProp, TypeCode.False));

            //Keep INIT, for those who use it
            IProposition initProposition = pn.InitProposition;
            toAdd.Push(Tuple.Create((IComponent)initProposition, TypeCode.Both));

            while (toAdd.Any())
            {
                //ConcurrencyUtils.checkForInterruption();
                Tuple<IComponent, TypeCode> curEntry = toAdd.Pop();
                IComponent curComp = curEntry.Item1;
                var newInputType = new Type(curEntry.Item2);
                Type oldType = reachability[curComp] ?? new Type(TypeCode.Neither);

                //We want to send only the new addition to our children,
                //for consistency in our parent-true and parent-false
                //counts.
                //Make sure we don't double-apply a type.

                var typeToAdd = new Type(TypeCode.Neither); // Any new values that we discover we can have this iteration.
                if (curComp is IProposition)
                    typeToAdd = newInputType;
                else if (curComp is ITransition)
                    typeToAdd = newInputType;
                else if (curComp is IConstant)
                    typeToAdd = newInputType;
                else if (curComp is INot)
                    typeToAdd = new Type(newInputType.Opposite());
                else if (curComp is IAnd)
                {
                    if (newInputType.HasTrue)
                    {
                        numTrueInputs.Add(curComp);
                        if (numTrueInputs.Count(n => n == curComp) == curComp.Inputs.Count)
                            typeToAdd = new Type(TypeCode.True);
                    }
                    if (newInputType.HasFalse)
                        typeToAdd = new Type(typeToAdd.With(TypeCode.False));
                }
                else if (curComp is IOr)
                {
                    if (newInputType.HasFalse)
                    {
                        numFalseInputs.Add(curComp);
                        if (numFalseInputs.Count(n => n == curComp) == curComp.Inputs.Count)
                            typeToAdd = new Type(TypeCode.False);
                    }
                    if (newInputType.HasTrue)
                        typeToAdd = new Type(typeToAdd.With(TypeCode.True));
                }
                else
                    throw new Exception("Unhandled component type " + curComp.GetType());

                if (oldType.Includes(typeToAdd)) //We don't know anything new about curComp
                    continue;

                reachability[curComp] = new Type(typeToAdd.With(oldType));
                typeToAdd = new Type(typeToAdd.Minus(oldType));
                if (typeToAdd == TypeCode.Neither)
//.........这里部分代码省略.........