C# Set.Contains方法代码示例

 public void ContainsTest()
 {
     Set<int> set = new Set<int>();
     set.Add(1);
     Assert.IsTrue(set.Contains(1));
     Assert.IsFalse(set.Contains(2));
 }

 public static List<CFGEdge> IsolateNodes(Set<CFGNode> nodes)
 {
     if (nodes.Count == 0)
     {
         return new List<CFGEdge>();
     }
     CFG graph = nodes[0].Graph;
     List<CFGEdge> removedEdges = new List<CFGEdge>();
     foreach (CFGNode node in nodes)
     {
         foreach (CFGEdge edge in graph.OutEdges(node))
         {
             if (!nodes.Contains(edge.Target))
             {
                 removedEdges.Add(edge);
             }
         }
         foreach (CFGEdge edge in graph.InEdges(node))
         {
             if (!nodes.Contains(edge.Source))
             {
                 removedEdges.Add(edge);
             }
         }
     }
     foreach (CFGEdge edge in removedEdges)
     {
         graph.RemoveEdge(edge);
     }
     return removedEdges;
 }

 public void SetTest()
 {
     var set = new Set<int>();
     set.Add(2);
     Assert.IsTrue(set.Contains(2));
     set.Delete(2);
     Assert.IsFalse(set.Contains(2));
 }

 public void AddArrayToNonEmptySet() {
    var set = new Set<int>();
    set.Add(11);
    set.Add(22);
    set.Add(new [] { 33, 44, 55 });
    Assert.Equals(5, set.Count);
    Assert.True(set.Contains(11));
    Assert.True(set.Contains(44));
 }

 public void TestIntersection()
 {
     var set =
         new Set<double>(value => 0d <= value && value < 2d).Intersection(
             new Set<double>(value => 1d < value && value <= 2d));
     Assert.IsFalse(set.Contains(0d));
     Assert.IsFalse(set.Contains(1d));
     Assert.IsFalse(set.Contains(2d));
 }

 public void TestUnion()
 {
     var set =
         new Set<double>(value => 0d < value && value <= 1d).Union(
             new Set<double>(value => 0d <= value && value < 2d));
     Assert.IsTrue(set.Contains(0d));
     Assert.IsTrue(set.Contains(1d));
     Assert.IsFalse(set.Contains(2d));
 }

 public void ShouldContains()
 {
     var collection = new Set<string>();
     collection.Add("1");
     collection.Add("2");
     collection.Add(null);  // Ignored
     Assert.IsTrue(collection.Contains("1"));
     Assert.IsFalse(collection.Contains("Hello"));
     Assert.IsFalse(collection.Contains(null));
 }

        public void TestIfFindFindsTheValue()
        {
            var set = new Set<int>();
            set.Add(5);
            set.Add(6);

            Assert.AreEqual(true, set.Contains(5));
            Assert.AreEqual(5, set.Find(5));
            Assert.AreEqual(false, set.Contains(7));
        }

 public void ContainsStoryTwoAddsHaveDifferentTimes()
 {
     var set = new Set<Story>();
     var story = new Story(new FrontpageItem { Title = "title", Link = "blah", Description = "shouldnt matter" });
     var story2 = new Story(new FrontpageItem { Title = "title", Link = "blah", Description = "diff but irrelevant" });
     set.Add(story);
     set.Add(story2);
     Assert.True(set.Contains(story));
     Assert.True(set.Contains(story2));
 }

 public static void TestSet()
 {
     Set<string> names = new Set<string>();
     names.Add("Jim");
     names.Add("Jones");
     Console.WriteLine("contains Jim? {0}", names.Contains("Jim"));
     Console.WriteLine("contains jim? {0}", names.Contains("jim"));
     names.Add("Jim");
     Console.WriteLine(names.Count);
     names.AddRange(new string[] { "Jones", "Jonny", "Michael" });
     Console.WriteLine(names.Count);
 }

		public void Init(FdoCache cache, bool enableCancel)
		{
			CheckDisposed();

			m_cache = cache;
			m_btnCancel.Visible = enableCancel;
			Set<int> revIdxWs = new Set<int>(4);
			foreach (IReversalIndex ri in cache.LanguageProject.LexDbOA.ReversalIndexesOC)
				revIdxWs.Add(m_cache.ServiceLocator.WritingSystemManager.GetWsFromStr(ri.WritingSystem));
			// Include only the analysis writing systems chosen by the user.  See LT-7514 and LT-7239.
			Set<int> activeWs = new Set<int>(cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Select(wsObj => wsObj.Handle));
			m_cbWritingSystems.Sorted = true;
			m_cbWritingSystems.DisplayMember = "Name";
			IWritingSystem selectedWs = null;
			foreach (IWritingSystem ws in cache.ServiceLocator.WritingSystems.AllWritingSystems)
			{
				if (revIdxWs.Contains(ws.Handle))
				{
					AddLanguageForExistingRevIdx(ws);
					continue;
				}
				if (!activeWs.Contains(ws.Handle))
					continue;
				m_cbWritingSystems.Items.Add(ws);
				if (selectedWs == null && !m_revIdx.Contains(ws.LanguageSubtag))
					selectedWs = ws;
			}
			if (selectedWs != null)
				m_cbWritingSystems.SelectedItem = selectedWs;
			if (m_cbWritingSystems.Items.Count > 0 && m_cbWritingSystems.SelectedIndex < 0)
				m_cbWritingSystems.SelectedIndex = 0;
			if (!enableCancel && m_cbWritingSystems.Items.Count == 0)
				throw new ApplicationException("Cancel is disabled, but there are none to choose, so the user has no way to get out of this dialog.");
		}

        public static void Main(string[] args)
        {
            var productsAndPrices = new OrderedMultiDictionary<int, string>(true);
            var rng = new Random();
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < 500000; i++)
            {
                var product = GenerateProduct(rng, i);
                var tokens = product.Split('|');
                var name = tokens[0].Trim();
                var price = int.Parse(tokens[1].Trim());
                productsAndPrices.Add(price, name);
            }

            Console.WriteLine("Seed time: " + stopwatch.Elapsed);
            stopwatch.Restart();
            Console.WriteLine("Query Start");
            var printed = new Set<int>();
            for (int i = 0; i < 10000; i++)
            {
                var startPrice = rng.Next(0, 100001);
                var endPrice = rng.Next(startPrice, 100001);
                var productsInRange = productsAndPrices.Range(startPrice, true, endPrice, true).Take(20);
                var count = productsInRange.Count();
                if (!printed.Contains(count))
                {
                    Console.WriteLine("{0} to {1} -> {2}", startPrice, endPrice, count);
                    printed.Add(count);
                }
            }

            Console.WriteLine("Query time: " + stopwatch.Elapsed);
            Console.WriteLine("All Done");
        }

        // function ELIMINATION-ASK(X, e, bn) returns a distribution over X
        /**
         * The ELIMINATION-ASK algorithm in Figure 14.11.
         * 
         * @param X
         *            the query variables.
         * @param e
         *            observed values for variables E.
         * @param bn
         *            a Bayes net with variables {X} ∪ E ∪ Y /* Y = hidden
         *            variables //
         * @return a distribution over the query variables.
         */

        public CategoricalDistribution eliminationAsk(RandomVariable[] X,
                                                      AssignmentProposition[] e, BayesianNetwork bn)
        {

            Set<RandomVariable> hidden = new Set<RandomVariable>();
            List<RandomVariable> VARS = new List<RandomVariable>();
            calculateVariables(X, e, bn, hidden, VARS);

            // factors <- []
            List<Factor> factors = new List<Factor>();
            // for each var in ORDER(bn.VARS) do
            foreach (RandomVariable var in order(bn, VARS))
            {
                // factors <- [MAKE-FACTOR(var, e) | factors]
                factors.Add(0, makeFactor(var, e, bn));
                // if var is hidden variable then factors <- SUM-OUT(var, factors)
                if (hidden.Contains(var))
                {
                    factors = sumOut(var, factors, bn);
                }
            }
            // return NORMALIZE(POINTWISE-PRODUCT(factors))
            Factor product = pointwiseProduct(factors);
            // Note: Want to ensure the order of the product matches the
            // query variables
            return ((ProbabilityTable) product.pointwiseProductPOS(_identity, X))
                .normalize();
        }

 public void ContainsStory()
 {
     var set = new Set<Story>();
     var story = new Story(new FrontpageItem { Title = "title", Link = "blah" });
     set.Add(story);
     Assert.True(set.Contains(story));
 }

        public void Contains_DataDrivenValues_AllShouldPass(int element, bool expected)
        {
            var set = new Set<int>(new[] { 1, 3, 5, 7, 9 });
            bool actual = set.Contains(element);

            Assert.Equal(expected, actual);
        }