C# HashSet.ToArray方法代码示例

	static void OnSavedScene ()
	{
		var behaviours = GameObject.FindObjectsOfType(typeof(MonoBehaviour));
		var assemblers = new HashSet<PrefabAssembler>();
		foreach(MonoBehaviour b in behaviours)
		{
			if(b.GetType().GetCustomAttributes(typeof(AssembleOnSave), true).Length == 0)
			{
				continue;
			}
			Transform target = b.transform;
			while(target)
			{
				var a = target.GetComponent<PrefabAssembler>();
				if(a)
				{
					assemblers.Add(a);
				}
				target = target.parent;
			}
		}
		if(assemblers.Count != 0)
		{
			PrefabAssembler.IsSaving = true;
			PrefabAssemblerUtility.Assemble(assemblers.ToArray());
			PrefabAssembler.IsSaving = false;
		}
	}

 public string GetSpecialAas()
 {
     Dictionary<char, int> count1 = new Dictionary<char, int>();
     Dictionary<char, int> count2 = new Dictionary<char, int>();
     foreach (string s in specificity){
         char c1 = s[0];
         char c2 = s[1];
         if (!count1.ContainsKey(c1)){
             count1.Add(c1, 0);
         }
         if (!count2.ContainsKey(c2)){
             count2.Add(c2, 0);
         }
         count1[c1]++;
         count2[c2]++;
     }
     HashSet<char> result = new HashSet<char>();
     foreach (char c in count1.Keys){
         if (count1[c] >= 17){
             result.Add(c);
         }
     }
     foreach (char c in count2.Keys){
         if (count2[c] >= 17){
             result.Add(c);
         }
     }
     return new string(result.ToArray());
 }

 public static void Run()
 {
     using (FastScanner fs = new FastScanner(new BufferedStream(Console.OpenStandardInput())))
     using (StreamWriter writer = new StreamWriter(new BufferedStream(Console.OpenStandardOutput())))
     {
         int n = fs.NextInt();
         HashSet<int> set = new HashSet<int>();
         for (int i = 0; i < n; i++)
         {
             int x = fs.NextInt();
             set.Add(x);
         }
         if (set.Count < 3)
         {
             writer.WriteLine("YES");
         }
         else if (set.Count > 3)
         {
             writer.WriteLine("NO");
         }
         else
         {
             int[] a = set.ToArray();
             Array.Sort(a);
             writer.WriteLine(a[1] - a[0] == a[2] - a[1] ? "YES" : "NO");
         }
     }
 }

		public static uint[] GetInstructionOffsets(MethodDef method, IList<MethodSourceStatement> list) {
			if (method == null)
				return null;
			var body = method.Body;
			if (body == null)
				return null;

			var foundInstrs = new HashSet<uint>();
			// The instructions' offset field is assumed to be valid
			var instrs = body.Instructions.Select(a => a.Offset).ToArray();
			foreach (var binSpan in list.Select(a => a.Statement.BinSpan)) {
				int index = Array.BinarySearch(instrs, binSpan.Start);
				if (index < 0)
					continue;
				for (int i = index; i < instrs.Length; i++) {
					uint instrOffset = instrs[i];
					if (instrOffset >= binSpan.End)
						break;

					foundInstrs.Add(instrOffset);
				}
			}

			return foundInstrs.ToArray();
		}

        private UnitTestInfo[] GetTests(string path, string[] hintPaths)
        {
            var codeGenDllPath = Assembly.GetExecutingAssembly().Location;

            var codegenDir = Path.GetDirectoryName(codeGenDllPath);
            
            AppDomain loaderDomain = AppDomain.CreateDomain(path, AppDomain.CurrentDomain.Evidence, new AppDomainSetup() { ApplicationBase = codegenDir });
            
            var loader = (TestAssemblyLoader)loaderDomain.CreateInstanceFromAndUnwrap(codeGenDllPath, typeof(TestAssemblyLoader).FullName);

            loader.InitializeLifetimeService();

            HashSet<string> hints = new HashSet<string>(hintPaths) { Path.GetDirectoryName(path) };
            
            loader.Load(path, hints.ToArray());

            UnitTestInfo[] tests = loader.GetTests<XUnitTestDiscoverer>();

            //if no xunit tests were discovered and the assembly is an exe treat as a standalone exe test
            if ((tests == null || tests.Length == 0) && Path.GetExtension(path).ToLowerInvariant() == ".exe")
            {
                tests = loader.GetTests<StandAloneTestDiscoverer>();
            }

            AppDomain.Unload(loaderDomain);

            if (tests.Length > 0)
            {
                CodeGenOutput.Info($"{path}: {tests.Length} tests discovered");
            }

            return tests;
        }

 public ScriptProjectGenerator(string[] _files, HashSet<string> assemblyReferences, ScriptSequence _sequence)
 {
     isCSharp = _sequence.Language.GetType().Name.Contains("CSharp");
     sequence = _sequence;
     files.AddRange(_files);
     references.AddRange(assemblyReferences.ToArray());
 }

		QueryTableDialog(IEnumerable<string> tables)
		{
			this.tables = new HashSet<string>(tables);
			InitializeComponent();
			tablesList.AddSuggestions(tables.ToArray());
			tablesList.IsDropDownOpen = true;
		}

        /// <summary>
        /// Creates a new object code file object.
        /// </summary>
        /// <param name="StartAddress">The load address of the object file.</param>
        /// <param name="Filename">The name of the object file.</param>
        /// <param name="Architecture">The targeted architecture of the object file.</param>
        /// <param name="Sections">The sections of the object file.</param>
        /// <param name="SymbolTable">The symbol table of the object file.</param>
        /// <param name="Code">The source code of the object file.</param>
        public ObjectCodeFile(long StartAddress, String Filename, String Architecture,
            Section[] Sections, SymbolTable SymbolTable, CodeUnit[] Code)
        {
            this.loadAddress  = StartAddress;
            this.Filepath     = Filename;
            this.Architecture = Architecture;
            this.Sections     = Sections;
            this.SymbolTable  = SymbolTable;
            this.Code         = Code;

            this.RequestedLoadAddress = StartAddress;

            // Sum loaded sections' sizes
            if (this.Sections != null)
            this.Size = this.Sections.Sum(
                sec => sec.Flags.HasFlag(SectionFlags.Load) ? (long)sec.Size : 0);

            // Get unique source file paths
            var tmpFiles = new HashSet<string>();

            foreach (CodeUnit unit in this.Code) {
                tmpFiles.Add(unit.SourceFilepath.Trim());
            }
            this.SourceFiles = tmpFiles.ToArray();
        }

		private void InitAssemblyCache()
		{
			if (this.assemblies != null) return;

			// Retrieve a list of all loaded, non-disposed Assemblies
			Assembly[] loadedAssemblies = 
				DualityApp.PluginLoader.LoadedAssemblies
				.Where(a => !DualityApp.PluginManager.DisposedPlugins.Contains(a))
				.ToArray();

			// Aggregate selectable assemblies based on Duality core Assemblies and their dependencies
			HashSet<Assembly> selectableAssemblies = new HashSet<Assembly>();
			foreach (Assembly coreAssembly in DualityApp.GetDualityAssemblies())
			{
				selectableAssemblies.Add(coreAssembly);

				AssemblyName[] referencedAssemblies = coreAssembly.GetReferencedAssemblies();
				foreach (AssemblyName reference in referencedAssemblies)
				{
					string shortName = reference.GetShortAssemblyName();
					Assembly dependency = loadedAssemblies.FirstOrDefault(a => a.GetShortAssemblyName() == shortName);
					if (dependency != null)
						selectableAssemblies.Add(dependency);
				}
			}

			this.assemblies = selectableAssemblies.ToArray();
			this.namespaces = this.assemblies
				.SelectMany(a => { try { return a.GetExportedTypes(); } catch (Exception) { return new Type[0]; } })
				.Select(t => t.Namespace)
				.Distinct()
				.Where(n => !string.IsNullOrEmpty(n))
				.ToArray();
		}

 private static BuildingInfo[] GetUniquePillars()
 {
     var pillarsTemp = new HashSet<BuildingInfo>();
     foreach (var buildingInfo in Util.GetAllPrefabs().SelectMany(prefab => prefab.GetPillars()))
     {
         pillarsTemp.Add(buildingInfo);
     }
     for (uint i = 0; i < PrefabCollection<BuildingInfo>.LoadedCount(); i++)
     {
         var prefab = PrefabCollection<BuildingInfo>.GetLoaded(i);
         if (prefab == null || prefab.m_buildingAI.GetType() != typeof(BuildingAI))
         {
             continue;
         }
         var asset = PackageManager.FindAssetByName(prefab.name);
         var crpPath = asset?.package?.packagePath;
         var directoryName = Path.GetDirectoryName(crpPath);
         if (directoryName == null)
         {
             continue;
         }
         var pillarConfigPath = Path.Combine(directoryName, "Pillar.xml");
         if (!File.Exists(pillarConfigPath))
         {
             continue;
         }
         pillarsTemp.Add(prefab);
     }
     return pillarsTemp.ToArray();
 }

        static void drawCodeGenerators(CodeGeneratorConfig codeGeneratorConfig, Type[] codeGenerators)
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Code Generators", EditorStyles.boldLabel);

            var enabledCodeGenerators = new HashSet<string>(codeGeneratorConfig.enabledCodeGenerators);

            var availableGeneratorNames = new HashSet<string>();
            foreach (var codeGenerator in codeGenerators) {
                availableGeneratorNames.Add(codeGenerator.Name);
                var isEnabled = enabledCodeGenerators.Contains(codeGenerator.Name);
                isEnabled = EditorGUILayout.Toggle(codeGenerator.Name, isEnabled);
                if (isEnabled) {
                    enabledCodeGenerators.Add(codeGenerator.Name);
                } else {
                    enabledCodeGenerators.Remove(codeGenerator.Name);
                }
            }

            foreach (var generatorName in codeGeneratorConfig.enabledCodeGenerators.ToArray()) {
                if (!availableGeneratorNames.Contains(generatorName)) {
                    enabledCodeGenerators.Remove(generatorName);
                }
            }

            var sortedCodeGenerators = enabledCodeGenerators.ToArray();
            Array.Sort(sortedCodeGenerators);
            codeGeneratorConfig.enabledCodeGenerators = sortedCodeGenerators;
        }

        static string[] ExtractParameters(string script)
        {
            var ps = ParameterExtractor.Matches(script);
            if (ps.Count == 0) return null;

            var ret = new HashSet<string>();

            for (var i = 0; i < ps.Count; i++)
            {
                var c = ps[i];
                var ix = c.Index - 1;
                if (ix >= 0)
                {
                    var prevChar = script[ix];
                    
                    // don't consider this a parameter if it's in the middle of word (ie. if it's preceeded by a letter)
                    if (char.IsLetterOrDigit(prevChar) || prevChar == '_') continue;
                    
                    // this is an escape, ignore it
                    if (prevChar == '@') continue;
                }

                var n = c.Groups["paramName"].Value;
                if (!ret.Contains(n)) ret.Add(n);
            }

            return ret.ToArray();
        }

 public static int[] many(int x)
 {
     ICollection<int> set = new HashSet<int>();
     while (set.Count < x)
         set.Add(RANDOM.Next(1, 50));
     return set.ToArray();
 }

 public override void Run(List<Point> points, List<Line> lines, List<Polygon> polygons, ref List<Point> outPoints, ref List<Line> outLines, ref List<Polygon> outPolygons)
 {
     HashSet<PointComparer> hashP = new HashSet<PointComparer>();
     for (int i = 0; i < points.Count; ++i)
         hashP.Add(new PointComparer(points[i]));
     PointComparer[] res = hashP.ToArray();
     points.Clear();
     for (int i = 0; i < res.Length; ++i)
         points.Add(res[i].p);
     List<bool> visited = new List<bool>();
     for (int i = 0; i < points.Count; ++i)
         visited.Add(false);
     for (int i = 0; i < points.Count; ++i)
     {
         for (int j = 0; j < points.Count; ++j)
             if (!visited[j])
                 for (int k = 0; k < points.Count; ++k)
                     if (!visited[k])
                         for (int l = 0; l < points.Count; ++l)
                             if (!visited[l] && (valid(i, j, k, l)))
                             {
                                 Enums.PointInPolygon state = HelperMethods.PointInTriangle(points[i], points[j], points[k], points[l]);
                                 if (state == Enums.PointInPolygon.Inside || state == Enums.PointInPolygon.OnEdge)
                                     visited[i] = true;
                             }
     }
     outPoints = new List<Point>();
     for (int i = 0; i < points.Count; ++i)
         if (!visited[i])
             outPoints.Add(points[i]);
     return;
 }

        public override void IndexDocuments(
			AbstractViewGenerator viewGenerator, 
			IEnumerable<dynamic> documents, 
			WorkContext context, 
			IStorageActionsAccessor actions, 
			DateTime minimumTimestamp)
        {
            actions.Indexing.SetCurrentIndexStatsTo(name);
            var count = 0;
            Func<object, object> documentIdFetcher = null;
            var reduceKeys = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
            var documentsWrapped = documents.Select(doc =>
            {
                var documentId = doc.__document_id;
                foreach (var reduceKey in actions.MappedResults.DeleteMappedResultsForDocumentId((string)documentId, name))
                {
                    reduceKeys.Add(reduceKey);
                }
                return doc;
            });
            foreach (var doc in RobustEnumeration(documentsWrapped, viewGenerator.MapDefinition, actions, context))
            {
                count++;

                documentIdFetcher = CreateDocumentIdFetcherIfNeeded(documentIdFetcher, doc);

                var docIdValue = documentIdFetcher(doc);
                if (docIdValue == null)
                    throw new InvalidOperationException("Could not find document id for this document");

                var reduceValue = viewGenerator.GroupByExtraction(doc);
                if (reduceValue == null)
                {
                    logIndexing.DebugFormat("Field {0} is used as the reduce key and cannot be null, skipping document {1}", viewGenerator.GroupByExtraction, docIdValue);
                    continue;
                }
                var reduceKey = ReduceKeyToString(reduceValue);
                var docId = docIdValue.ToString();

                reduceKeys.Add(reduceKey);

                var data = GetMapedData(doc);

                logIndexing.DebugFormat("Mapped result for '{0}': '{1}'", name, data);

                var hash = ComputeHash(name, reduceKey);

                actions.MappedResults.PutMappedResult(name, docId, reduceKey, data, hash);

                actions.Indexing.IncrementSuccessIndexing();
            }

            actions.Tasks.AddTask(new ReduceTask
            {
                Index = name,
                ReduceKeys = reduceKeys.ToArray()
            }, minimumTimestamp);

            logIndexing.DebugFormat("Mapped {0} documents for {1}", count, name);
        }