C# Dictionary.ToList方法代码示例

        private void SendNotificationEmail(string message)
        {
            var templateName = "exception_report";

            var exceptionRecipients = ReadConfig.CommonCloudCoreApplicationSettings.ExceptionRecipients;
            var recipients = new List<EmailRecipient>();
            for (int index = 0; index < exceptionRecipients.Count; index++)
            {
                recipients.Add(new EmailRecipient() { RecipientEmail = exceptionRecipients[index].RecipientAddress });
            }

            if (recipients.Any())
            {
                var globalVariables = new Dictionary<string, string>
                {
                    { "exceptioncontent", message.Replace("\n", "<br />") },
                    { "subject", "Exception Report" },
                };

                var postageAppClient = new PostageAppClient()
                {
                    TemplateName = templateName,
                    GlobalVariables = globalVariables.ToList(),
                    Recipients = recipients
                };

                postageAppClient.Send();
            }
        }

        public IList GetBingLanguages()
        {
            var languages = new Dictionary<string, string>
                                {
                                    {"Arabic", "ar"},
                                    {"Czech", "cs"},
                                    {"Danish", "da"},
                                    {"German", "de"},
                                    {"English", "en"},
                                    {"Estonian", "et"},
                                    {"Finnish", "fi"},
                                    {"French", "fr"},
                                    {"Dutch", "nl"},
                                    {"Greek", "el"},
                                    {"Hebrew", "he"},
                                    {"Haitian Creole", "ht"},
                                    {"Hungarian", "hu"},
                                    {"Indonesian", "id"},
                                    {"Italian", "it"},
                                    {"Japanese", "ja"},
                                    {"Korean", "ko"},
                                    {"Lithuanian", "lt"},
                                    {"Latvian", "lv"},
                                    {"Norwegian", "no"},
                                    {"Polish", "pl"},
                                    {"Portuguese", "pt"},
                                    {"Romanian", "ro"},
                                    {"Spanish", "es"},
                                    {"Russian", "ru"},
                                    {"Slovak", "sk"},
                                    {"Slovene", "sl"},
                                    {"Swedish", "sv"},
                                    {"Thai", "th"},
                                    {"Turkish", "tr"},
                                    {"Ukrainian", "uk"},
                                    {"Vietnamese", "vi"},
                                    {"Simplified Chinese", "zh-CHS"},
                                    {"Traditional Chinese", "zh-CHT"}
                                };

            return languages.ToList();
        }

		public IronPythonComposablePart(IronPythonTypeWrapper typeWrapper, IEnumerable<Type> exports, IEnumerable<KeyValuePair<string, IronPythonImportDefinition>> imports, IDictionary<object, object> exportMetadatas)
		{
			_typeWrapper = typeWrapper;
			_instance = typeWrapper.Activator();
			_exports = new List<ExportDefinition>(exports.Count());
			_imports = new Dictionary<string, ImportDefinition>(imports.Count());
			foreach (var export in exports)
			{
				var metadata = new Dictionary<string, object>()
                                   {
                                       {"ExportTypeIdentity", AttributedModelServices.GetTypeIdentity(export)}
                                   };

				if (exportMetadatas != null)
				{
					foreach (var data in exportMetadatas)
					{
						metadata.Add(data.Key.ToString(), data.Value);
					}
				}

				var contractName = AttributedModelServices.GetContractName(export);
				_exports.Add(new ExportDefinition(contractName, metadata));
			}
			foreach (var import in imports)
			{
				var contractName = AttributedModelServices.GetContractName(import.Value.Type);
				var metadata = new Dictionary<string, Type>();

				_imports[import.Key] = new IronPythonContractBasedImportDefinition(
					import.Key,
					contractName,
					AttributedModelServices.GetTypeIdentity(import.Value.Type),
					metadata.ToList(),
					import.Value.Cardinality, import.Value.IsRecomposable, import.Value.IsPrerequisite,
					CreationPolicy.Any);
			}
		}

        public IList GetGoogleLanguages()
        {
            var languages = new Dictionary<string, string>
                                {
                                    {"Afrikaans", "af"},
                                    {"Albanian", "sq"},
                                    {"Arabic", "ar"},
                                    {"Belarusian", "be"},
                                    {"Bulgarian", "bg"},
                                    {"Catalan", "ca"},
                                    {"Chinese Simplified", "zh-CN"},
                                    {"Chinese Traditional", "zh-TW"},
                                    {"Croatian", "hr"},
                                    {"Czech", "cs"},
                                    {"Danish", "da"},
                                    {"Dutch", "nl"},
                                    {"English", "en"},
                                    {"Estonian", "et"},
                                    {"Filipino", "tl"},
                                    {"Finnish", "fi"},
                                    {"French", "fr"},
                                    {"Galician", "gl"},
                                    {"German", "de"},
                                    {"Greek", "el"},
                                    {"Haitian Creole", "ht"},
                                    {"Hebrew", "iw"},
                                    {"Hindi", "hi"},
                                    {"Hungarian", "hu"},
                                    {"Icelandic", "is"},
                                    {"Indonesian", "id"},
                                    {"Irish", "ga"},
                                    {"Italian", "it"},
                                    {"Japanese", "ja"},
                                    {"Latvian", "lv"},
                                    {"Lithuanian", "lt"},
                                    {"Macedonian", "mk"},
                                    {"Malay", "ms"},
                                    {"Maltese", "mt"},
                                    {"Norwegian", "no"},
                                    {"Persian", "fa"},
                                    {"Polish", "pl"},
                                    {"Portuguese", "pt"},
                                    {"Romanian", "ro"},
                                    {"Russian", "ru"},
                                    {"Serbian", "sr"},
                                    {"Slovak", "sk"},
                                    {"Slovenian", "sl"},
                                    {"Spanish", "es"},
                                    {"Swahili", "sw"},
                                    {"Swedish", "sv"},
                                    {"Thai", "th"},
                                    {"Turkish", "tr"},
                                    {"Ukrainian", "uk"},
                                    {"Vietnamese", "vi"},
                                    {"Welsh", "cy"},
                                    {"Yiddish", "yi"}
                                };

            return languages.ToList();
        }

		private void validateMergedCellBorder(RtfTableCell representative, Direction dir)
		{
			if (!representative.IsMerged) {
				throw new Exception("Invalid representative (cell is not merged).");
			}
			Dictionary<Border, int> stat = new Dictionary<Border, int>();
			Border majorityBorder;
			int majorityCount;
			int limit = (dir == Direction.Top || dir == Direction.Bottom) ? 
				representative.MergeInfo.ColSpan : representative.MergeInfo.RowSpan;
			
			for (int i = 0; i < limit; i++) {
				int r, c;
				Border bdr;
				if (dir == Direction.Top || dir == Direction.Bottom) {
					if (dir == Direction.Top) {
						r = 0;
					} else { // dir == bottom
						r = representative.MergeInfo.RowSpan - 1;
					}
					c = i;
				} else { // dir == right || left
					if (dir == Direction.Right) {
						c = representative.MergeInfo.ColSpan - 1;
					} else { // dir == left
						c = 0;
					}
					r = i;
				}
				bdr = _cells[representative.RowIndex + r][representative.ColIndex + c].Borders[dir];
				if (stat.ContainsKey(bdr)) {
					stat[bdr] = (int)stat[bdr] + 1;
				} else {
					stat[bdr] = 1;
				}
			}
			majorityCount = -1;
			majorityBorder = representative.Borders[dir];
			foreach(KeyValuePair<Border, int> de in stat.ToList()) {
				if(de.Value > majorityCount) {
					majorityCount = de.Value;
					majorityBorder.Style = de.Key.Style;
					majorityBorder.Width = de.Key.Width;
					majorityBorder.Color = de.Key.Color;
				}
			}
		}

        /// <summary>
        /// Gets a <see cref="FrameworkTemplate"/> based on the specified parameters.
        /// </summary>
        /// <param name="xmlElement">The xml element to get template xaml from.</param>
        /// <param name="parentObject">The <see cref="XamlObject"/> to use as source for resources and contextual information.</param>
        /// <returns>A <see cref="FrameworkTemplate"/> based on the specified parameters.</returns>
        public static FrameworkTemplate GetFrameworkTemplate(XmlElement xmlElement, XamlObject parentObject)
        {
            var nav = xmlElement.CreateNavigator();

            var ns = new Dictionary<string, string>();
            while (true)
            {
                var nsInScope = nav.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
                foreach (var ak in nsInScope)
                {
                    if (!ns.ContainsKey(ak.Key) && ak.Key != "")
                        ns.Add(ak.Key, ak.Value);
                }
                if (!nav.MoveToParent())
                    break;
            }

            xmlElement = (XmlElement)xmlElement.CloneNode(true);

            foreach (var dictentry in ns.ToList())
            {
                var value = dictentry.Value;
                if (value.StartsWith("clr-namespace") && !value.Contains(";assembly=")) {
                    if (!string.IsNullOrEmpty(parentObject.OwnerDocument.CurrentProjectAssemblyName)) {
                        value += ";assembly=" + parentObject.OwnerDocument.CurrentProjectAssemblyName;
                    }
                }
                xmlElement.SetAttribute("xmlns:" + dictentry.Key, value);
            }

            var keyAttrib = xmlElement.GetAttribute("Key", XamlConstants.XamlNamespace);

            if (string.IsNullOrEmpty(keyAttrib)) {
                xmlElement.SetAttribute("Key", XamlConstants.XamlNamespace, "$$temp&&§§%%__");
            }

            var xaml = xmlElement.OuterXml;
            xaml = "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/netfx/2007/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">" + xaml + "</ResourceDictionary>";
            StringReader stringReader = new StringReader(xaml);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            var xamlReader = new XamlXmlReader(xmlReader, parentObject.ServiceProvider.SchemaContext);

            var seti = new XamlObjectWriterSettings();

            var resourceDictionary = new ResourceDictionary();
            var obj = parentObject;
            while (obj != null)
            {
                if (obj.Instance is ResourceDictionary)
                {
                    var r = obj.Instance as ResourceDictionary;
                    foreach (var k in r.Keys)
                    {
                        if (!resourceDictionary.Contains(k))
                            resourceDictionary.Add(k, r[k]);
                    }
                }
                else if (obj.Instance is FrameworkElement)
                {
                    var r = ((FrameworkElement)obj.Instance).Resources;
                    foreach (var k in r.Keys)
                    {
                        if (!resourceDictionary.Contains(k))
                            resourceDictionary.Add(k, r[k]);
                    }
                }

                obj = obj.ParentObject;
            }

            seti.BeforePropertiesHandler = (s, e) =>
            {
                if (seti.BeforePropertiesHandler != null)
                {
                    var rr = e.Instance as ResourceDictionary;
                    rr.MergedDictionaries.Add(resourceDictionary);
                    seti.BeforePropertiesHandler = null;
                }
            };

            var writer = new XamlObjectWriter(parentObject.ServiceProvider.SchemaContext, seti);

            XamlServices.Transform(xamlReader, writer);

            var result = (ResourceDictionary)writer.Result;

            var enr = result.Keys.GetEnumerator();
            enr.MoveNext();
            var rdKey = enr.Current;

            var template = result[rdKey] as FrameworkTemplate;

            result.Remove(rdKey);
            return template;
//.........这里部分代码省略.........

        /// <summary>
        /// Builds the report.
        /// </summary>
        /// <param name="reportDocument">The report document.</param>
        public void BuildReport(ICustomReport reportDocument)
        {
            var currentReport = reportDocument.Reports.First();

            SetIdentity(currentReport);
            //_originalPageHeaderHeight = ((PageHeaderSection) currentReport.Items["pageHeader"]).Height;

            //This report parameter holds the current template system name.
            _processName = currentReport.ReportParameters["processName"].Value.ToString();

            //This report parameter holds the currently visible columns of the grid and in what order they're in
            var cols = currentReport.ReportParameters["columns"].Value.ToString();

            var columns = cols.Split(';').ToList();
            _columns = new List<ColumnInfo>();
            foreach (var col in columns)
            {
                _columns.Add(new ColumnInfo(col));
            }

            var groupsStr = currentReport.ReportParameters["groups"].Value.ToString();
            _groups = (string.IsNullOrEmpty(groupsStr) ? new string[0] : groupsStr.Split(';')).ToList();

            //TODO: Uncomment if needed
           // _columns.AddRange(_groups);

            if (reportDocument.FitToPage)
            {
                if (currentReport.GetType().Name.ToLower().Contains("landscape"))
                {
                    FitToPageColumnWidth = Math.Min(1, 10.0 / _columns.Count);
                    FitToPageColumnCount = (short) Math.Max(10, _columns.Count);
                }

                if (currentReport.GetType().Name.ToLower().Contains("portrait"))
                {
                    FitToPageColumnWidth = Math.Min(1.1, 7.0 / _columns.Count);
                    FitToPageColumnCount = (short) Math.Max(7, _columns.Count);
                }

                currentReport.Width = new Unit(_columns.Count * FitToPageColumnWidth, UnitType.Inch);
            }

            _groupColumn = currentReport.ReportParameters["groupColumn"].Value.ToString();

            var fldList = new List<FieldInfo>(_columns.Count);

            var processProperties = new Dictionary<PropertyInfo, string>();
            var processType = TheDynamicTypeManager.GetInfoType<IInfoClass>(_processName);

            if (processType != null)
            {
                processProperties = processType.GetAllPropertiesWithPaths();
                var properties = processProperties.Where(p => _columns.Any(c=>c.SystemName == p.Value));

                foreach (var column in _columns)
                {
                    foreach (var property in properties)
                    {
                        if (property.Value == column.SystemName)
                        {
                            fldList.Add(new FieldInfo(property.Key, column));
                            break;
                        }
                    }
                }

                _fieldAttrDict = GetFieldAttributes(processProperties.Select(x => x.Key));
            }

            if (_fieldAttrDict == null)
                _fieldAttrDict = new Dictionary<PropertyInfo, FieldParametres>();

            _colDict = new SortedDictionary<int, string[]>();

            //Grouping            
            foreach (var colName in _groups)
            {
                var group = new Telerik.Reporting.Group();
                group.Name = colName;
                var groupHeaderSection = new GroupHeaderSection();
                var groupFooterSection = new GroupFooterSection();
                group.GroupHeader = groupHeaderSection;
                group.GroupFooter = groupFooterSection;

                var txt = new TextBox();
                txt.Style.Font.Size = new Unit(10, UnitType.Point);
                txt.Style.Font.Bold = true;
                txt.Style.BackgroundColor = Color.FromArgb(255, 225, 225, 225);
                txt.Style.TextAlign = HorizontalAlign.Left;
                txt.Style.VerticalAlign = VerticalAlign.Middle;
                groupHeaderSection.Items.Add(txt);
                groupHeaderSection.Height = new Unit(21);
                groupHeaderSection.Style.BorderStyle.Default = BorderType.Solid;
                groupHeaderSection.Style.BorderColor.Default = Color.White;
                groupHeaderSection.Style.BorderColor.Left = Color.Transparent;
//.........这里部分代码省略.........

        private void CleanupModel(Dictionary<string, object> model)
        {
            foreach (var entry in model.ToList())
            {
                var value = entry.Value;
                var list = value as ArrayList;
                if (list != null)
                {
                    var objs = list.OfType<object>().ToList();
                    model[entry.Key] = objs;
                    value = objs;

                    //continue;
                }

                var enumerable = value as IEnumerable<object>;
                if (enumerable != null)
                {
                    foreach (var item in enumerable)
                    {
                        var dItem = item as Dictionary<string, object>;
                        if (dItem != null)
                            CleanupModel(dItem);
                    }
                }

                var dict = value as Dictionary<string, object>;
                if (dict != null)
                    CleanupModel(dict);
            }
        }

        Document CreateUpdateDocument( SetItemDocumentParameters p )
        {
            var doc = new Document();

            var map = new Dictionary<string, object>
                          {
                              {"$set", p.Set},
                              {"$inc", p.Inc},
                              {"$pop", p.Pop},
                              {"$pull", p.Pull},
                              {"$pullAll", p.PullAll},
                              {"$push", p.Push},
                              {"$pushAll", p.PushAll},
                              {"$rename", p.Rename},
                              {"$unset", p.Unset},
                              {"$bit", p.Bit}
                          };

            map.ToList().ForEach( pair=> AppendUpdateAtomDocument(doc, pair.Key, pair.Value ) );

            return doc;
        }

        public static void pngToTgaRectNesting(string path, string filter = "*.png", int deep = 0, bool isPreset = false)
        {
            Dictionary<string, RectNode> mapRectNode = new Dictionary<string, RectNode>();
            string projPath = Project.Setting.s_projPath;
            int presetCount = 0;
            int fileCount = 0;

            printString("========开始打包========\r\n" + "路径：" + path + "\r\n");
            fileCount = addFileToArr(path, filter, mapRectNode);

            if (fileCount == 0)
            {
                return;
            }
            if (isPreset)
            {
                DirectoryInfo di = new DirectoryInfo(projPath + "\\images\\");
                DirectoryInfo[] arrPreDri = di.GetDirectories("*_preset*");
                DirectoryInfo[] arrAllDri = di.GetDirectories("*");

                if (arrPreDri.Count() != arrAllDri.Count())
                {
                    MessageBox.Show("存在自定义图片分包，无法进行预设打包。", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
                printString("模式：预设打包\r\n");
                presetCount = getRectNestingByPreset(mapRectNode, conf_maxSizeOfPreset, conf_maxSizeOfPreset);
            }
            else
            {
                bool isFirst = true;
                int maxPow = 0;

                //得到预期的2的整数次幂
                maxPow = getMaxPow(mapRectNode.Values.ToList());
                s_fileCount = mapRectNode.Count;

                printString("模式：开发打包\r\n");
                do
                {
                    if (isFirst)
                    {
                        isFirst = false;
                        printString("文件数量:" + mapRectNode.Count + "\r\ntga图片预计尺寸:" + Math.Pow(2, maxPow) + "\r\n");
                    }
                    else
                    {
                        maxPow++;
                        printString("本次尝试失败，尝试下一尺寸...\r\ntga图片预计尺寸:" + Math.Pow(2, maxPow) + "\r\n");
                    }
                } while (!getRectNesting(mapRectNode, (int)Math.Pow(2, maxPow), (int)Math.Pow(2, maxPow)));
            }

            if (path.Last() == '\\')
            {
                path = path.Remove(path.Length - 1);
                if (path.Last() == '\\')
                {
                    path = path.Remove(path.Length - 1);
                }
            }

            if (isPreset && presetCount != 0)
            {
                DirectoryInfo di = new DirectoryInfo(projPath + "\\images\\");
                DirectoryInfo[] arrDirInfo = di.GetDirectories("*_preset*");
                XmlDocument docRes = new XmlDocument();
                XmlElement xeResRoot = docRes.CreateElement("BoloUI");

                foreach(DirectoryInfo dri in arrDirInfo)
                {
                    Directory.Delete(dri.FullName, true);
                }

                XmlDocument[] arrDocGrid = new XmlDocument[presetCount];

                for (int i = 0; i < presetCount; i++)
                {
                    arrDocGrid[i] = new XmlDocument();
                    XmlElement xeRoot = arrDocGrid[i].CreateElement("UIImageResource");
                    arrDocGrid[i].AppendChild(xeRoot);
                    Directory.CreateDirectory(projPath + "\\images\\_preset" + (i + 1).ToString("00"));

                    XmlElement xeRes = docRes.CreateElement("resource");

                    xeRes.SetAttribute("name", "_preset" + (i + 1).ToString("00"));
                    xeResRoot.AppendChild(xeRes);
                }

                foreach (KeyValuePair<string, RectNode> pairRn in mapRectNode.ToList())
                {
                    XmlDocument docGrid = arrDocGrid[pairRn.Value.m_packCount];
                    XmlElement xe = docGrid.CreateElement("Image");
                    string name = pairRn.Key.Remove(pairRn.Key.LastIndexOf("."));

                    xe.SetAttribute("Name", name);
                    //因为差值什么的显示问题，所以要-2和+1。
                    xe.SetAttribute("Width", (pairRn.Value.m_rect.Width - 2).ToString());
                    xe.SetAttribute("Height", (pairRn.Value.m_rect.Height - 2).ToString());
                    xe.SetAttribute("X", (pairRn.Value.m_rect.X + 1).ToString());
//.........这里部分代码省略.........

        public void ConstructSortedDictionary(DataBase db)
        {
            var sortedDistDict = new Dictionary<PointPair, float>();
            for (int i=0; i<NumOfRows; ++i)
            {
                for (int j=0; j<i; ++j)
                {
                    if (i != j)
                        sortedDistDict.Add(new PointPair(i, j), Point.Distance(db[i], db[j]));
                }
            }

            sortedDistList = sortedDistDict.ToList();
            sortedDistList.Sort((firstPair, nextPair) =>
            {
                return firstPair.Value.CompareTo(nextPair.Value);
            });
        }

        /// <summary>
        /// Generates a full list of headers from a list of applications.
        /// This includes the base list of headers for application metadata, as well
        /// as the combination of all fields in all applications (in the event that the form
        /// definition changes).
        /// </summary>
        /// <param name="applications">List of applications.</param>
        /// <returns>A key-value pair of headers and sub headers.</returns>
        public List<KeyValuePair<string, List<string>>> GenerateHeaders(IEnumerable<Application> applications)
        {
            if (applications == null || !applications.Any())
            {
                return null;
            }

            Dictionary<string, Dictionary<string, object>> headers = new Dictionary<string, Dictionary<string, object>>();
            foreach (var prop in applications.First().GetType().GetProperties().Where(prop => prop.Name != "ApplicationData").Select(prop => prop.Name))
            {
                headers.Add(prop, null);
                if (this.userByTypes.Contains(prop))
                {
                    headers.Add(prop + "DisplayName", null);
                }
            }

            foreach (var app in applications)
            {
                if (app.ApplicationData != null)
                {
                    this.ExtractHeaders(app.ApplicationData, headers);
                }
            }

            var finalHeaders = headers.ToList().Select(header => new KeyValuePair<string, List<string>>(header.Key, header.Value != null ? header.Value.Keys.ToList() : null)).ToList();
            return finalHeaders;
        }

 private void setLengths(List<Artifact> allArtifacts)
 {
     Dictionary<Artifact, int> descLengths = new Dictionary<Artifact, int>();
     foreach (Artifact a in allArtifacts)
     {
         int len = a.Function.Length + a.CanadianSignificance.Length + a.TechSignificance.Length;
         if(len > 0)
             descLengths.Add(a, len);
     }
     descLengths = descLengths.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value);
     //descLengths = descLengths.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value);
     descLengthsList = descLengths.ToList();
 }

        /// <summary>
        /// Calculates the khipu auth header value
        /// </summary>
        /// <param name="path">Request path.</param>
        /// <param name="method">Request method.</param>
        /// <param name="queryParams">Query parameters.</param>
        /// <param name="formParams">Form parameters.</param>
        public String AuthHeader(String path, RestSharp.Method method, Dictionary<String, String> queryParams, Dictionary<String, String> formParams) {
            Dictionary<String, String> ps = new Dictionary<String, String>();
            queryParams.ToList().ForEach(x => ps[x.Key] = x.Value);
            formParams.ToList().ForEach(x => ps[x.Key] = x.Value);

            List<String> keys = new List<String>(ps.Keys.OrderBy(q => q));
            String toSign = method + "&" + Uri.EscapeDataString(BasePath + path);

            foreach(var key in keys)
                toSign += "&" + Uri.EscapeDataString(key) + "=" + Uri.EscapeDataString(ps[key]);

            String hmac = HmacSha256(Configuration.Secret, toSign);
            return Configuration.ReceiverId + ":" + hmac;
        }

//.........这里部分代码省略.........

                        }
                        else
                        {
                            eidcount = (uint)rd.Next(31, 51);

                            if (!tmpeset.Contains(eidcount))
                            {
                                tmpeset.Add(eidcount);
                                if (!this.eventlist.Contains(eidcount))
                                    this.eventlist.Add(eidcount);
                                //sw[i].Write(eidcount);
                            }
                            else
                            {
                                while (tmpeset.Contains(eidcount))
                                {
                                    eidcount = (uint)rd.Next(11, 31);
                                }
                                tmpeset.Add(eidcount);
                                if (!this.eventlist.Contains(eidcount))
                                    this.eventlist.Add(eidcount);
                                //sw[i].Write(eidcount);
                            }
                        }
                       
                        //sw[i].Write(" ");
                        tmpdic.Add(eidcount,sid);
                   
                       
                        
                    }
                    tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
                    tmplist = tmpdic.ToList();
                    for(k = 0; k < tmplist.Count; k++){
                        sw[i].Write(tmplist[k].Key);
                        sw[i].Write(" ");
                        sw[i].Write(tmplist[k].Value);
                        sw[i].Write(" ");
                    }
                    
                    tmpeset.Clear();
                    tmpdic.Clear();
                    sw[i].Write("\n");
                }

                layernum = (uint)(Math.Pow(2, beginsynlayer + 1));
                layernum = (uint)((layernum + layernum*4*(totallayer-beginsynlayer-1))*(totallayer-beginsynlayer))/2; 
                for (k = 0; k < layernum; k++ )
                {
                    current = generatelts.Dequeue();
                    sidbegin = current * 4;
                    if (rd.Next(0, 2) == 0)
                    {
                        for (m = 0; m < 4; m++)
                        {
                            sid = sidbegin + (uint)m;
                            generatelts.Enqueue(sid);
                            Allsnum++;
                            if (i == 0)
                            {
                                eidcount = (uint)rd.Next(11, 31);

                                if (!tmpeset.Contains(eidcount))
                                {
                                    tmpeset.Add(eidcount);