public static void ShowParsedCommand(ConsoleCommand consoleCommand, TextWriter consoleOut) { if (!consoleCommand.TraceCommandAfterParse) { return; } string[] skippedProperties = new []{ "Command", "OneLineDescription", "Options", "TraceCommandAfterParse", "RemainingArgumentsCount", "RemainingArgumentsHelpText", "RequiredOptions" }; var properties = consoleCommand.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(p => !skippedProperties.Contains(p.Name)); var fields = consoleCommand.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance) .Where(p => !skippedProperties.Contains(p.Name)); Dictionary<string,string> allValuesToTrace = new Dictionary<string, string>(); foreach (var property in properties) { object value = property.GetValue(consoleCommand, new object[0]); allValuesToTrace[property.Name] = value != null ? value.ToString() : "null"; } foreach (var field in fields) { allValuesToTrace[field.Name] = MakeObjectReadable(field.GetValue(consoleCommand)); } consoleOut.WriteLine(); string introLine = String.Format("Executing {0}", consoleCommand.Command); if (string.IsNullOrEmpty(consoleCommand.OneLineDescription)) introLine = introLine + ":"; else introLine = introLine + " (" + consoleCommand.OneLineDescription + "):"; consoleOut.WriteLine(introLine); foreach(var value in allValuesToTrace.OrderBy(k => k.Key)) consoleOut.WriteLine(" " + value.Key + " : " + value.Value); consoleOut.WriteLine(); }
public void Initialize(bool blockUnrated) { if (_ratings != null) return; //already intitialized //We get our ratings from the server _ratings = new Dictionary<string, int>(); try { foreach (var rating in Kernel.ApiClient.GetParentalRatings()) { _ratings.Add(rating.Name, rating.Value); } } catch (Exception e) { Logging.Logger.ReportException("Error retrieving ratings from server",e); return; } try { _ratings.Add("", blockUnrated ? 1000 : 0); } catch (Exception e) { Logging.Logger.ReportException("Error adding blank value to ratings", e); } //and rating reverse lookup dictionary (non-redundant ones) ratingsStrings.Clear(); int lastLevel = -10; ratingsStrings.Add(-1,LocalizedStrings.Instance.GetString("Any")); foreach (var pair in _ratings.OrderBy(p => p.Value)) { if (pair.Value > lastLevel) { lastLevel = pair.Value; try { ratingsStrings.Add(pair.Value, pair.Key); } catch (Exception e) { Logging.Logger.ReportException("Error adding "+pair.Value+" to ratings strings", e); } } } }
private IEnumerable<string> GetColumns() { var columns = new Dictionary<int, string>(); foreach (PropertyInfo propertyInfo in _type.GetProperties()) { var attribute = Attributes.GetAttribute<UserDefinedTableTypeColumnAttribute>(propertyInfo); if (attribute != null) columns.Add(attribute.Order, propertyInfo.Name); } var sortedColumns = columns.OrderBy(kvp => kvp.Key); return sortedColumns.Select(kvp => kvp.Value); }
/// <summary> /// Returns the string for the Authorisation header to be used for OAuth authentication. /// Parameters other than OAuth ones are ignored. /// </summary> /// <param name="parameters">OAuth and other parameters.</param> /// <returns></returns> public static string OAuthCalculateAuthHeader(Dictionary<string, string> parameters) { StringBuilder sb = new StringBuilder("OAuth "); var sorted = parameters.OrderBy(x => x.Key); foreach (KeyValuePair<string, string> pair in sorted) { if (pair.Key.StartsWith("oauth")) { sb.Append(pair.Key + "=\"" + Uri.EscapeDataString(pair.Value) + "\","); } } return sb.Remove(sb.Length - 1, 1).ToString(); }
public override IEnumerable GetDistribution(Release[] releases) { Dictionary<string, int> result = new Dictionary<string, int>(); foreach (Release release in releases) { if (!string.IsNullOrEmpty(release.Country)) { if (!result.ContainsKey(release.Country)) { result[release.Country] = 0; } ++result[release.Country]; } } var allItems = result.OrderBy(i => -i.Value); var topItems = allItems.Take(6); var otherItems = allItems.Skip(6); int otherItemsSum = otherItems.Sum(i => i.Value); foreach (var topItem in topItems) { yield return new Item() { Key = topItem.Key + " (" + topItem.Value + ")", Value = topItem.Value, Countries = new string[] { topItem.Key }, }; } if (otherItemsSum != 0) { yield return new Item() { Key = "Other (" + otherItemsSum + ")", Value = otherItemsSum, Countries = otherItems.Select(i => i.Key).ToArray() }; } }
public static void SortChildren(this IDomObject node) { if (node.ChildNodes.Count == 0) return; var buffer = new Dictionary<string, IDomObject>(); foreach (var child in node.ChildNodes) { var value = GetValueBasedOnNode(child); if (!string.IsNullOrWhiteSpace(value)) { buffer.Add(value, child); } } node.ChildNodes.Clear(); var sorted = buffer.OrderBy(x => x.Key); foreach (var kvp in sorted) { node.ChildNodes.Add(kvp.Value); } }
public static string ProcessUniqueTerms(Index index) { _index = index; // initialize the rank dictionary Dictionary<int, double> rank = new Dictionary<int, double>(); foreach (KeyValuePair<int, string> document in _index.documents) rank.Add(document.Key, 0.0); // loop though all of the documents in the index foreach (KeyValuePair<int, string> document in _index.documents) { rank[document.Key] = ((double)UniqueTermsCount(document.Value) / _index.GetDocumentLength(document.Key)); } // calculate the results StringBuilder sb = new StringBuilder(); foreach (KeyValuePair<int, double> result in rank.OrderBy(z => z.Value)) { sb.AppendLine(result.Key.ToString() + " " + result.Value.ToString()); } return sb.ToString(); }
/// <summary> /// Determine popularity of classes for the selection process using the lists /// </summary> public void verifyPopularity() { AllClasses = new Dictionary<String, int>(); ThirdClasses = new Dictionary<String, int>(); SecondClasses = new Dictionary<String, int>(); FirstClasses = new Dictionary<String, int>(); foreach(Presenter currentPresenter in presenterList) { AllClasses.Add(currentPresenter.PresenterTitle, 0); #region Loop over all requests and populate dictionaries foreach (Request currentRequest in requestList) { string presenterName = currentPresenter.PresenterTitle; if (currentRequest.RequestOne.Equals(presenterName) || currentRequest.RequestTwo.Equals(presenterName) || currentRequest.RequestThree.Equals(presenterName) || currentRequest.RequestFour.Equals(presenterName) || currentRequest.RequestFive.Equals(presenterName)) { if (AllClasses.ContainsKey(presenterName)) { int currentCount = AllClasses[presenterName]; ++currentCount; AllClasses[presenterName] = currentCount; } else { AllClasses.Add(presenterName, 1); } } if (currentRequest.RequestThree.Equals(presenterName) ) { if (ThirdClasses.ContainsKey(presenterName)) { int currentCount = ThirdClasses[presenterName]; ++currentCount; ThirdClasses[presenterName] = currentCount; } else { ThirdClasses.Add(presenterName, 1); } } if (currentRequest.RequestTwo.Equals(presenterName) ) { if (SecondClasses.ContainsKey(presenterName)) { int currentCount = SecondClasses[presenterName]; ++currentCount; SecondClasses[presenterName] = currentCount; } else { SecondClasses.Add(presenterName, 1); } } if (currentRequest.RequestOne.Equals(presenterName)) { if (FirstClasses.ContainsKey(presenterName)) { int currentCount = FirstClasses[presenterName]; ++currentCount; FirstClasses[presenterName] = currentCount; } else { FirstClasses.Add(presenterName, 1); } } } #endregion } AllClasses = AllClasses.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value); ThirdClasses = ThirdClasses.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value); SecondClasses = SecondClasses.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value); FirstClasses = FirstClasses.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value); }
private void WriteDicionaryBase(object input) { int count = ((DictionaryBase) input).Count; WritePrimativeObject(count, typeof(int)); IDictionaryEnumerator dicEnum = (input as DictionaryBase).GetEnumerator(); var keyValList = new Dictionary<object, object>(); while (dicEnum.MoveNext()) { keyValList[dicEnum.Key] = dicEnum.Value; } var query = keyValList.OrderBy(keyVal => keyVal.Key.ToString()); foreach (KeyValuePair<object, object> keyValuePair in query) { WriteObject(keyValuePair.Key); WriteObject(keyValuePair.Value); } //while (dicEnum.MoveNext()) //{ // WriteObject(dicEnum.Key); // WriteObject(dicEnum.Value); //} // Custom fields WriteCustomFields(input); }
private void solidLoad(Info n) { Dictionary<string, int> keycache = new Dictionary<string, int>(); SpecialBitmap jz; getAngleMap(n, jz = new SpecialBitmap(dir2 + "plane solid ang 1.png"), keycache, 1); getAngleMap(n, jz = new SpecialBitmap(dir2 + "plane solid ang 2.png"), keycache, 2); getHightMap(n, jz = new SpecialBitmap(dir2 + "plane solid n 1.png"), keycache, 1); getHightMap(n, jz = new SpecialBitmap(dir2 + "plane solid n 2.png"), keycache, 2); n.HeightMaps = keycache.OrderBy(a => a.Value).Select(a => a.Key).ToArray(); }
/// <summary> /// Describes the schema of the underlying data and services to the K2 platform. /// </summary> public void DescribeSchema() { TypeMappings map = GetTypeMappings(); PDFInfo info = new PDFInfo(); Dictionary<string, PDFField> fields = new Dictionary<string,PDFField>(); // get PDDocument try { using (PdfReader doc = new PdfReader(pdfUri)) { // discover pdf doc info = GetPDFDoucmentInformation(doc); fields = DiscoverPDFFormFields(doc); } } catch (Exception ex) { throw; } // create objects ServiceObject pdfServiceObject = new ServiceObject(); pdfServiceObject.Name = info.Title.Replace(" ", "_"); pdfServiceObject.MetaData.DisplayName = info.Title; pdfServiceObject.Active = true; List<Property> allprops = new List<Property>(); List<Property> allfields = new List<Property>(); List<Property> allmetadata = new List<Property>(); Property inputUriproperty = new Property(); inputUriproperty.Name = "pdfuri"; inputUriproperty.MetaData.DisplayName = "PDF Uri"; inputUriproperty.Type = typeof(System.String).ToString(); inputUriproperty.SoType = SoType.Text; pdfServiceObject.Properties.Add(inputUriproperty); // has signatures Property hasSigsProperty = new Property(); hasSigsProperty.Name = "containssignatures"; hasSigsProperty.MetaData.DisplayName = "Contains Signatures"; hasSigsProperty.Type = typeof(System.Boolean).ToString(); hasSigsProperty.SoType = SoType.YesNo; pdfServiceObject.Properties.Add(hasSigsProperty); // has unsigned signatures Property containsUnsignedSigsProperty = new Property(); containsUnsignedSigsProperty.Name = "containsunsignedsignatures"; containsUnsignedSigsProperty.MetaData.DisplayName = "Contains Unsigned Signatures"; containsUnsignedSigsProperty.Type = typeof(System.Boolean).ToString(); containsUnsignedSigsProperty.SoType = SoType.YesNo; pdfServiceObject.Properties.Add(containsUnsignedSigsProperty); // for update - return base64? Property includebase64Property = new Property(); includebase64Property.Name = "returnbase64"; includebase64Property.MetaData.DisplayName = "Return Base64"; includebase64Property.Type = typeof(System.Boolean).ToString(); includebase64Property.SoType = SoType.YesNo; pdfServiceObject.Properties.Add(includebase64Property); // for update - base64 Property base64Property = new Property(); base64Property.Name = "base64pdf"; base64Property.MetaData.DisplayName = "Base64 PDF"; base64Property.Type = typeof(System.String).ToString(); base64Property.SoType = SoType.Memo; pdfServiceObject.Properties.Add(base64Property); // for update - return path Property returnpathProperty = new Property(); returnpathProperty.Name = "returnpath"; returnpathProperty.MetaData.DisplayName = "Return Path"; returnpathProperty.Type = typeof(System.String).ToString(); returnpathProperty.SoType = SoType.Text; pdfServiceObject.Properties.Add(returnpathProperty); Type type = typeof(PDFInfo); PropertyInfo[] props = type.GetProperties(); foreach (var p in props) { //text += docinfo.GetType().GetProperty(field.Name).GetValue(docinfo, null); Property infoproperty = new Property(); infoproperty.Name = p.Name; infoproperty.MetaData.DisplayName = p.Name; infoproperty.Type = p.PropertyType.ToString(); // needs to be mapped properly infoproperty.SoType = SoType.Text; pdfServiceObject.Properties.Add(infoproperty); allmetadata.Add(infoproperty); allprops.Add(infoproperty); } foreach (KeyValuePair<string, PDFField> field in fields.OrderBy(p => p.Key)) { Property property = new Property(); property.Name = field.Value.FullName.Replace(" ", "_"); property.MetaData.DisplayName = field.Value.FullName; property.Type = typeof(System.String).ToString(); property.SoType = SoType.Text; property.MetaData.ServiceProperties.Add("pdffullname", field.Value.FullName); property.MetaData.ServiceProperties.Add("pdfalternativename", field.Value.AlternativeName); property.MetaData.ServiceProperties.Add("pdfisreadonly", field.Value.IsReadOnly); property.MetaData.ServiceProperties.Add("pdfisrequired", field.Value.IsRequired); property.MetaData.ServiceProperties.Add("pdfpartialname", field.Value.PartialName); property.MetaData.ServiceProperties.Add("pdftype", field.Value.Type); allfields.Add(property); allprops.Add(property); pdfServiceObject.Properties.Add(property); } // add methods Method GetAllFieldValues = new Method(); GetAllFieldValues.Name = "getallfieldvalues"; GetAllFieldValues.MetaData.DisplayName = "Get All Field Values"; GetAllFieldValues.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Read; GetAllFieldValues.InputProperties.Add(inputUriproperty); GetAllFieldValues.Validation.RequiredProperties.Add(inputUriproperty); GetAllFieldValues.ReturnProperties.Add(inputUriproperty); foreach (Property prop in allprops) { GetAllFieldValues.ReturnProperties.Add(prop); } pdfServiceObject.Methods.Add(GetAllFieldValues); // contains signatures method Method HasSigs = new Method(); HasSigs.Name = "containssignatures"; HasSigs.MetaData.DisplayName = "Contains Signatures"; HasSigs.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Read; HasSigs.InputProperties.Add(inputUriproperty); HasSigs.Validation.RequiredProperties.Add(inputUriproperty); HasSigs.ReturnProperties.Add(inputUriproperty); HasSigs.ReturnProperties.Add(hasSigsProperty); pdfServiceObject.Methods.Add(HasSigs); // contains unsigned signatures method Method ContainsUnsigned = new Method(); ContainsUnsigned.Name = "containsunsignedsignatures"; ContainsUnsigned.MetaData.DisplayName = "Contains Unsigned Signatures"; ContainsUnsigned.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Read; ContainsUnsigned.InputProperties.Add(inputUriproperty); ContainsUnsigned.Validation.RequiredProperties.Add(inputUriproperty); ContainsUnsigned.ReturnProperties.Add(inputUriproperty); ContainsUnsigned.ReturnProperties.Add(containsUnsignedSigsProperty); pdfServiceObject.Methods.Add(ContainsUnsigned); // add update Method UpdateMethod = new Method(); UpdateMethod.Name = "updatepdffields"; UpdateMethod.MetaData.DisplayName = "Update PDF Fields"; UpdateMethod.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Update; UpdateMethod.InputProperties.Add(inputUriproperty); UpdateMethod.Validation.RequiredProperties.Add(inputUriproperty); UpdateMethod.InputProperties.Add(includebase64Property); UpdateMethod.Validation.RequiredProperties.Add(includebase64Property); foreach (Property prop in allfields) { UpdateMethod.InputProperties.Add(prop); } UpdateMethod.ReturnProperties.Add(inputUriproperty); UpdateMethod.ReturnProperties.Add(includebase64Property); foreach (Property prop in allprops) { UpdateMethod.ReturnProperties.Add(prop); } UpdateMethod.ReturnProperties.Add(returnpathProperty); UpdateMethod.ReturnProperties.Add(base64Property); pdfServiceObject.Methods.Add(UpdateMethod); if (!serviceBroker.Service.ServiceObjects.Contains(pdfServiceObject)) { serviceBroker.Service.ServiceObjects.Add(pdfServiceObject); } // admin object ServiceObject adminServiceObject = new ServiceObject(); adminServiceObject.Name = "Functions" + info.Title.Replace(" ", "_"); adminServiceObject.MetaData.DisplayName = "Functions - " + info.Title; adminServiceObject.Active = true; adminServiceObject.Properties.Add(inputUriproperty); Property sqlProperty = new Property(); sqlProperty.Name = "generatedsql"; sqlProperty.MetaData.DisplayName = "Generated SQL"; sqlProperty.Type = typeof(System.String).ToString(); sqlProperty.SoType = SoType.Memo; adminServiceObject.Properties.Add(sqlProperty); // generate create table sql Method generateCreateTable = new Method(); generateCreateTable.Name = "generatecreatetablesql"; generateCreateTable.MetaData.DisplayName = "Generate Create Table SQL"; generateCreateTable.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Read; generateCreateTable.ReturnProperties.Add(sqlProperty); adminServiceObject.Methods.Add(generateCreateTable); Property smoProperty = new Property(); smoProperty.Name = "formstoresmartobjectname"; smoProperty.MetaData.DisplayName = "Form Store SmartObject Name"; smoProperty.Type = typeof(System.String).ToString(); smoProperty.SoType = SoType.Text; adminServiceObject.Properties.Add(smoProperty); Property smoMethodProperty = new Property(); smoMethodProperty.Name = "formstoremethodname"; smoMethodProperty.MetaData.DisplayName = "Form Store Method Name"; smoMethodProperty.Type = typeof(System.String).ToString(); smoMethodProperty.SoType = SoType.Text; adminServiceObject.Properties.Add(smoMethodProperty); Property smoIdProperty = new Property(); smoIdProperty.Name = "returnidpropertyname"; smoIdProperty.MetaData.DisplayName = "Return Id Property Name"; smoIdProperty.Type = typeof(System.String).ToString(); smoIdProperty.SoType = SoType.Text; adminServiceObject.Properties.Add(smoIdProperty); Property returnIdProperty = new Property(); returnIdProperty.Name = "returnid"; returnIdProperty.MetaData.DisplayName = "Return Id"; returnIdProperty.Type = typeof(System.String).ToString(); returnIdProperty.SoType = SoType.Text; adminServiceObject.Properties.Add(returnIdProperty); // copy form data to smartobject Method copyFormData = new Method(); copyFormData.Name = "copyformdatatosmartobject"; copyFormData.MetaData.DisplayName = "Copy Form Data to SmartObject"; copyFormData.Type = SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType.Read; copyFormData.InputProperties.Add(inputUriproperty); copyFormData.Validation.RequiredProperties.Add(inputUriproperty); copyFormData.ReturnProperties.Add(inputUriproperty); copyFormData.InputProperties.Add(smoProperty); copyFormData.Validation.RequiredProperties.Add(smoProperty); copyFormData.ReturnProperties.Add(smoProperty); copyFormData.InputProperties.Add(smoMethodProperty); copyFormData.Validation.RequiredProperties.Add(smoMethodProperty); copyFormData.ReturnProperties.Add(smoMethodProperty); copyFormData.InputProperties.Add(smoIdProperty); copyFormData.Validation.RequiredProperties.Add(smoIdProperty); copyFormData.ReturnProperties.Add(smoIdProperty); copyFormData.ReturnProperties.Add(returnIdProperty); adminServiceObject.Methods.Add(copyFormData); if (!serviceBroker.Service.ServiceObjects.Contains(adminServiceObject)) { serviceBroker.Service.ServiceObjects.Add(adminServiceObject); } }
// print in the order private static void reOrderPipeLine(Dictionary<string, int> clusterList, StreamWriter output) { foreach (var data in clusterList.OrderBy(key => key.Value)) { output.WriteLine(data.Key); } }
void Sort(List<MmlResolvedEvent> l) { var msgBlockByTime = new Dictionary<int,List<MmlResolvedEvent>> (); int m = 0; int prev = 0; while (m < l.Count) { var e = l [m]; List<MmlResolvedEvent> pl; if (!msgBlockByTime.TryGetValue (l [m].Tick, out pl)) { pl = new List<MmlResolvedEvent> (); msgBlockByTime.Add (e.Tick, pl); } for (; m < l.Count; m++) { pl.Add (l [m]); if (m + 1 < l.Count && l [m + 1].Tick != prev) break; } m++; } l.Clear (); foreach (var sl in msgBlockByTime.OrderBy (kvp => kvp.Key).Select (kvp => kvp.Value)) l.AddRange (sl); }
//Return the contained search key private string[] GetContainedSearchKeys(string[] searchKeys, string line) { searchKeys = RemovePartialWords(searchKeys.Where(k => line.IndexOf(k, StringComparison.InvariantCultureIgnoreCase) >= 0).ToArray()); var containedKeys = new Dictionary<String, int>(); foreach (string key in searchKeys) { var index = line.IndexOf(key, StringComparison.InvariantCultureIgnoreCase); if (index >= 0) { containedKeys.Add(key, index); } } return containedKeys.OrderBy(p => p.Value).Select(p => p.Key).ToArray(); }
public void Problem16() { Dictionary<string, double> d = new Dictionary<string,double>(); int f; Console.ReadLineQ<int>(out f, "Fjöldi"); for (int i = 0; i < f; i++) { string n; double h, t; Console.ReadLineQ(out n, "Nafn " + (i + 1)).ReadLineQ<double>(out h, "Hæð " + (i + 1)).ReadLineQ<double>(out t, "Þyngd " + (i + 1)); Console.WriteLine("\n"); d.Add(n, t / Math.Pow(h, 2)); } foreach (var i in d.OrderBy(x => x.Value)) { Console.WriteLine("{0} {1:0.#}" ,i.Key, i.Value); } }
/// <summary> /// Export this ResxData to an .xlsx file /// /// Adds a first page with instructions /// </summary> /// <param name="outputPath">Path to write .xlsx file to</param> public void ToXls(string outputPath, string screenshotsPath, Action<string> addSummaryDelegate) { Excel.Application app = new Excel.Application(); Excel.Workbook wb = app.Workbooks.Add(Excel.XlWBATemplate.xlWBATWorksheet); Excel.Sheets sheets = wb.Worksheets; var cultures = this.exportCultures.Select(c => c.Name).ToList(); var firstSheet = app.ActiveSheet as Excel.Worksheet; int sheetIndex = firstSheet.Index; // Iterate over all filesources that have keys assigned var filesources = this.PrimaryTranslation.Select(r => r.ResxRow.FileSource) .Distinct(); var filesourcesdict = new Dictionary<string, string>(); foreach (var filesource in filesources) { // Create a dictionary for name:relative_path for all resx files var name = Regex.Replace(filesource, @"^.*\\", ""); name = Regex.Replace(name, @"\.[^\.]*$", ""); name = name.Substring(0, Math.Min(name.Length, 31)); Debug.Assert(!filesourcesdict.ContainsKey(name), "Resource files with same name exist."); filesourcesdict.Add(name, filesource); } foreach (var filesource in filesourcesdict.OrderBy(kvp => kvp.Key)) { // add sheet var sheet = sheets.Add(After: sheets[sheetIndex]) as Excel.Worksheet; sheet.Name = filesource.Key; sheetIndex = sheet.Index; addSummaryDelegate("Created sheet " + filesource.Key); FillXlsSheet(screenshotsPath, cultures, filesource, sheet); } // Make the first sheet active CreateExplanationSheet(firstSheet); ((Excel._Worksheet)firstSheet).Activate(); // Save the Workbook and force overwriting by rename trick string tmpFile = Path.GetTempFileName(); File.Delete(tmpFile); Excel.XlFileFormat fileFormat = Path.GetExtension(outputPath) == ".xls" ? Excel.XlFileFormat.xlExcel8 : Excel.XlFileFormat.xlWorkbookDefault; wb.SaveAs(Filename: tmpFile, AccessMode: Excel.XlSaveAsAccessMode.xlNoChange, FileFormat: fileFormat); File.Delete(outputPath); ExcelQuit(app, wb); // Move file otherwise handle is still used by excel File.Move(tmpFile, outputPath); if (!string.IsNullOrEmpty(this.ReadResxReport)) { File.WriteAllText(outputPath + ".log", this.ReadResxReport); } }
static List<MergeAction> FindDuplicateStories(Dictionary<long, SimpleStory> stories) { List<MergeAction> mergeActions = new List<MergeAction>(); foreach (SimpleStory story in stories.OrderBy(n => n.Key).Select(n => n.Value)) { var newerStories = stories .Where(n => n.Key > story.StoryID).OrderBy(n => n.Key).Select(n => n.Value); if (!newerStories.Any()) break; //Get the distribution of similarity scores between this cluster and each of the most active stories var similarities = newerStories .Select(n => new { StoryID = n.StoryID, Similarity = n.WordVector * story.WordVector }) .OrderByDescending(n => n.Similarity) .ToList(); //Check if there is a rapid drop somewhere in the similarity distribution bool distrHasRapidDrop = false; if (similarities.Count > 1) { for (int i = 1; i < similarities.Count; i++) { if (similarities[i].Similarity > 0.01 && similarities[i].Similarity < Settings.TweetClusterer_SW_MergeDropScale * similarities[i - 1].Similarity) { distrHasRapidDrop = true; break; } } } //Merge the stories if similar if ((similarities[0].Similarity > Settings.TweetClusterer_SW_MergeThreshold || similarities[0].Similarity > Settings.TweetClusterer_SW_MergeThresholdWithDrop && distrHasRapidDrop)) { long targetStoryID = story.StoryID; var thisStoryMerges = mergeActions.Where(n => n.MergedStoryID == story.StoryID); if (thisStoryMerges.Any()) targetStoryID = thisStoryMerges.Min(n => n.KeptStoryID); mergeActions.Add(new MergeAction() { KeptStoryID = targetStoryID, MergedStoryID = similarities[0].StoryID }); } } return mergeActions; }
public void InitializeTwoParameterAdd(bool useInterpreter) { Expression<Func<Dictionary<string, int>>> dictInit = () => new Dictionary<string, int> { { "a", 1 }, {"b", 2 }, {"c", 3 } }; Func<Dictionary<string, int>> func = dictInit.Compile(useInterpreter); var expected = new Dictionary<string, int> { { "a", 1 }, {"b", 2 }, {"c", 3 } }; Assert.Equal(expected.OrderBy(kvp => kvp.Key), func().OrderBy(kvp => kvp.Key)); }
public static string CreateOauthSignature(Dictionary<string, string> dic, string url, string method, string consumer_secret, string oauth_token_secret) { string HashKey = consumer_secret + "&" + oauth_token_secret; string OauthSignature = ""; string Paras = ""; string BaseString = method + "&" + RFC3986_UrlEncode(url) + "&"; Paras = RFC3986_UrlEncode(dic.OrderBy(x => x.Key).ToDictionary(x => x.Key, y => y.Value).ToQueryString()); BaseString += Paras; using (HMACSHA1 crypto = new HMACSHA1()) { crypto.Key = Encoding.ASCII.GetBytes(HashKey); OauthSignature = Convert.ToBase64String(crypto.ComputeHash(Encoding.ASCII.GetBytes(BaseString))); } return OauthSignature; }
private void GenerateMethod(Type interfaceType, FieldBuilder handlerField, TypeBuilder typeBuilder) { MetaDataFactory.Add(interfaceType); // Obtém a lista de todos os métodos a serem criados. MethodInfo[] interfaceMethods = interfaceType.GetMethods().OrderBy(p => p.Name).ToArray(); // Verifica se existe algum método a ser implementado na interface. if (interfaceMethods != null) { // Cria cada um dos métodos definidos na interface. for (int i = 0; i < interfaceMethods.Length; i++) { MethodInfo methodInfo = interfaceMethods[i]; // Obtém os parâmetros do método que está sendo criado. ParameterInfo[] methodParams = methodInfo.GetParameters(); int numOfParams = methodParams.Length; Type[] methodParameters = new Type[numOfParams]; // Armazena o tipo de cada parâmetro do método. for (int j = 0; j < numOfParams; j++) { methodParameters[j] = methodParams[j].ParameterType; } // Armazena todos os tipos genéricos do método. Type[] genericArguments = methodInfo.GetGenericArguments(); MethodBuilder methodBuilder = null; // Verifica se o método não possui tipos genéricos. if (genericArguments.Length == 0) { // Cria um MethodBuilder para o método da interface que esta sendo criado. Como não há tipos genéricos, a definição é feita em apenas uma etapa. methodBuilder = typeBuilder.DefineMethod( methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, CallingConventions.Standard, methodInfo.ReturnType, methodParameters); } else { // Cria um MethodBuilder que deverá ser preenchido em etapas, pois os tipos genéricos do método precisam ser identificados. methodBuilder = typeBuilder.DefineMethod( methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, CallingConventions.Standard); // Define o tipo de retorno do método. methodBuilder.SetReturnType(methodInfo.ReturnType); Dictionary<int, string> typeParamNames = new Dictionary<int, string>(); Dictionary<int, Type> parameters = new Dictionary<int, Type>(); int currentIndex = 0; // Analisa todos os parâmetros do método. foreach (ParameterInfo parameterInfo in methodParams) { // Caso o parâmetro não possua a propriedade FullName preenchida, indica que é um tipo genérico. Caso contrário, é um tipo forte. if (parameterInfo.ParameterType.FullName == null) { typeParamNames.Add(currentIndex, parameterInfo.ParameterType.Name); } else { parameters.Add(currentIndex, parameterInfo.ParameterType); } currentIndex++; } // Verifica se existe algum tipo genérico. if (typeParamNames.Count > 0) { // Informa ao MethodBuilder os nomes dos tipos genéricos. GenericTypeParameterBuilder[] typeParameters = methodBuilder.DefineGenericParameters(typeParamNames.Values.ToArray()); // Adiciona os tipos genéricos na lista de tipos do método. for (int j = 0; j < typeParameters.Length; j++) { int parameterIndex = typeParamNames.ElementAt(j).Key; parameters.Add(parameterIndex, typeParameters[j]); } // Define o tipo de retorno do método. methodBuilder.SetReturnType(methodInfo.ReturnType); } // Verifica se o tipo de retorno é um tipo genérico. else if (methodInfo.ReturnType.IsGenericParameter == true) { // Informa ao MethodBuilder o nome do tipo genérico. GenericTypeParameterBuilder[] returnParameter = methodBuilder.DefineGenericParameters(methodInfo.ReturnType.Name); // Define o tipo de retorno do método. methodBuilder.SetReturnType(returnParameter[0]); } else { // Informa ao MethodBuilder os nomes dos tipos genéricos. methodBuilder.DefineGenericParameters(genericArguments.Select(p => p.Name).ToArray()); } IEnumerable<Type> orderedParameters = parameters.OrderBy(p => p.Key).Select(p => p.Value); // Informa ao MethodBuilder os nomes de todos os parâmetros do método. methodBuilder.SetParameters(orderedParameters.ToArray()); } #region( "Handler Method IL Code" ) bool hasReturnValue = (methodInfo.ReturnType.Equals(typeof(void)) == false); ILGenerator methodIL = methodBuilder.GetILGenerator(); // Sempre declare um array para conter os parâmetros para o método a ser chamado pelo proxy. methodIL.DeclareLocal(typeof(System.Object[])); // Emite a declaração de uma variável local, caso exista um tipo de retorno para o método. if (hasReturnValue == true) { methodIL.DeclareLocal(methodInfo.ReturnType); //if (methodInfo.ReturnType.IsValueType && (methodInfo.ReturnType.IsPrimitive == false)) { // methodIL.DeclareLocal(methodInfo.ReturnType); //} } // Cria um label para indicar onde o uso do proxy é iniciado. Label handlerLabel = methodIL.DefineLabel(); // Cria um label para indicar onde está a saída do método (return). Label returnLabel = methodIL.DefineLabel(); // Carrega "this" no stack. methodIL.Emit(OpCodes.Ldarg_0); // Carrega o handler para o proxy. methodIL.Emit(OpCodes.Ldfld, handlerField); // Caso exista um proxy, pula para o label que será utilizado para executá-lo. methodIL.Emit(OpCodes.Brtrue_S, handlerLabel); // Verifica se o método possui retorno. if (hasReturnValue == true) { // Caso seja um tipo primitivo apenas cria a variável de retorno, com o valor default do tipo. if (methodInfo.ReturnType.IsValueType && methodInfo.ReturnType.IsPrimitive == false && methodInfo.ReturnType.IsEnum == false && (methodInfo.ReturnType.IsGenericType && methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Nullable<>)) == false) { //methodIL.Emit(OpCodes.Ldloc_1); methodIL.Emit(OpCodes.Ldloc_0); } // Caso o retorno seja uma classe, carrega nulo na variável de retorno. else { methodIL.Emit(OpCodes.Ldnull); } // Armazena o valor de retorno. methodIL.Emit(OpCodes.Stloc_0); // Passa para o fim do método. //methodIL.Emit(OpCodes.Br_S, returnLabel); methodIL.Emit(OpCodes.Br, returnLabel); } else { // Passa para o fim do método. //methodIL.Emit(OpCodes.Br_S, returnLabel); methodIL.Emit(OpCodes.Br, returnLabel); } // Define o label que indica o início do trecho de execução do proxy. methodIL.MarkLabel(handlerLabel); // Carrega "this" no stack. methodIL.Emit(OpCodes.Ldarg_0); // Carrega o handler para o IDinamicProxy. methodIL.Emit(OpCodes.Ldfld, handlerField); // Carrega "this" no stack. Será utilizado para chamar o método GetMethod mais abaixo. methodIL.Emit(OpCodes.Ldarg_0); // Carrega o nome da interface no stack. methodIL.Emit(OpCodes.Ldstr, interfaceType.FullName); // Carrega o índice do método no stack. methodIL.Emit(OpCodes.Ldc_I4, i); // Executa o método GetMethod da classe MetaDataFactory, passando como parâmetros o nome da interface e o índice do método, carregados no stack. methodIL.Emit(OpCodes.Call, typeof(MetaDataFactory).GetMethod("GetMethod", new Type[] { typeof(string), typeof(int) })); // Carrega a quantidade de parâmetros do método no topo do stack. methodIL.Emit(OpCodes.Ldc_I4, numOfParams); // Cria um array de objetos. A quantidade de parâmetros carregados no stack é utilizado para definir o tamanho do array. methodIL.Emit(OpCodes.Newarr, typeof(System.Object)); // Adiciona cada parâmetro existente na lista de parâmetros que serão utilizados ao invocar o método concreto. if (numOfParams > 0) { //methodIL.Emit(OpCodes.Stloc_1); methodIL.Emit(OpCodes.Stloc_0); for (int j = 0; j < numOfParams; j++) { //methodIL.Emit(OpCodes.Ldloc_1); methodIL.Emit(OpCodes.Ldloc_0); methodIL.Emit(OpCodes.Ldc_I4, j); methodIL.Emit(OpCodes.Ldarg, j + 1); if (methodParameters[j].IsValueType) { methodIL.Emit(OpCodes.Box, methodParameters[j]); } methodIL.Emit(OpCodes.Stelem_Ref); } //methodIL.Emit(OpCodes.Ldloc_1); methodIL.Emit(OpCodes.Ldloc_0); } // Carrega a quantidade de argumentos genéricos para criar o próximo array. methodIL.Emit(OpCodes.Ldc_I4, genericArguments.Length); // Cria um array que conterá todos os tipos genéricos do método. methodIL.Emit(OpCodes.Newarr, typeof(System.Type)); // Adicionamos o tipo de cada parâmetro genérico no array. if (genericArguments.Length > 0) { // Salva o array. methodIL.Emit(OpCodes.Stloc_0); // Obtém cada parâmetro genérico a ser adicionado. for (int j = 0; j < genericArguments.Length; j++) { // Carrega o array. methodIL.Emit(OpCodes.Ldloc_0); // Seleciona a posição j do array. methodIL.Emit(OpCodes.Ldc_I4, j); // Carrega o item a ser adicionado no array. methodIL.Emit(OpCodes.Ldtoken, genericArguments[j]); // Caso o parâmetro seja value type, é preciso fazer box. if (genericArguments[j].IsValueType) { methodIL.Emit(OpCodes.Box, genericArguments[j]); } // Insere o item no array. methodIL.Emit(OpCodes.Stelem_Ref); } // Carrega o array preenchido, para que seja usado no método a seguir. methodIL.Emit(OpCodes.Ldloc_0); } // Chama o método concreto através do Invoke. methodIL.Emit(OpCodes.Callvirt, typeof(IDynamicProxy).GetMethod("Invoke")); // Verifica se o método possui returno. if (hasReturnValue == true) { // Faz o unbox do valor de retorno, caso seja um valueType ou generic. if (methodInfo.ReturnType.IsValueType == true || methodInfo.ReturnType.IsGenericParameter == true) { methodIL.Emit(OpCodes.Unbox, methodInfo.ReturnType); if (methodInfo.ReturnType.IsEnum) { methodIL.Emit(OpCodes.Ldind_I4); } else if (methodInfo.ReturnType.IsPrimitive == false) { methodIL.Emit(OpCodes.Ldobj, methodInfo.ReturnType); } else { methodIL.Emit((OpCode)opCodeTypeMapper[methodInfo.ReturnType]); } } else { methodIL.Emit(OpCodes.Castclass, methodInfo.ReturnType); } // Armazena o valor retornado pelo método Invoke. //methodIL.Emit(OpCodes.Stloc_0); methodIL.Emit(OpCodes.Stloc_1); // Pula para o label de saída do método. //methodIL.Emit(OpCodes.Br_S, returnLabel); methodIL.Emit(OpCodes.Br, returnLabel); // Define o label para o ponto de saída do método; methodIL.MarkLabel(returnLabel); // Carrega o valor armazenado antes de retornar. Será nulo, caso não exista retorno, ou será o valor retornado pelo método Invoke. //methodIL.Emit(OpCodes.Ldloc_0); methodIL.Emit(OpCodes.Ldloc_1); } else { // Como o método não possui retorno, remove qualquer valor armazenado antes de retornar. methodIL.Emit(OpCodes.Pop); // Define o label para o ponto de saída do método; methodIL.MarkLabel(returnLabel); } // Define o ponto de saída do método (return); methodIL.Emit(OpCodes.Ret); #endregion } } // Chama todas as demais interfaces herdadas pela interface atual, recursivamente. foreach (Type parentType in interfaceType.GetInterfaces()) { GenerateMethod(parentType, handlerField, typeBuilder); } }
private void button8_Click_1(object sender, EventArgs e) { List<string> final_lst = new List<string>(); ListViewItem li; string[] arr = new string[3]; string col1 = ""; string col2 = ""; // treeView2.Nodes.Add("Topical Tweets"); // treeView3.Nodes.Add("Topical Tweets"); foreach (string data in c1) { col2 = ""; foreach (string str in collfin3) { //if (str.Contains("#")) //{ // //if (!str.Contains("#followfriday") && !str.Contains("#ff") && !str.Contains("#FF") && !str.Contains("#follow friday") && !str.Contains("was") && !str.Contains("had")) // //{ // // treeView2.Nodes[0].Nodes.Add(str); // // //string col1= // //} // //else // //{ // // if (!str.Contains("#followfriday") && !str.Contains("#ff") && !str.Contains("#FF") && !str.Contains("#follow friday")) // // treeView3.Nodes[0].Nodes.Add(str); // //} //} //else //{ List<string> gern = new List<string>() { }; if (str.Contains(data)) { //if (!str.Contains("was") && !str.Contains("had")) //{ // treeView2.Nodes[0].Nodes.Add(str); col1 = data; //col2 = ""; var coll_col2 = str.Split(' '); gern = coll_col2.ToList(); foreach (string chk in rem_topic) { gern.Remove(chk); } foreach (string spli_str in gern) { if (spli_str.Length > 5) { if (!col2.Contains(spli_str)) { col2 += spli_str + ", "; } } } if(!final_lst .Contains (col2 )) final_lst.Add(col2); // } //else //{ // treeView3.Nodes[0].Nodes.Add(str); //} } } // } if (col2 != "") { //Random r = new Random(); //int num = r.Next(10, 50); //arr[0] = col1; //arr[1] = col2; //arr[2] = num.ToString(); //li = new ListViewItem(arr); //listView2.Items.Add(li); } //col2 = ""; } Random r1 = new Random(); int num1 = r1.Next(8, 15); List<int> re=new List<int> (); for (int j = 0; j < num1; ) { Random r = new Random(); int num = r.Next(j, 25); if (!re.Contains(num)) { re.Add(num); j = j + 1; } } //for(int i=0;i<num1;i++) //{ // //arr[0] = col1; // arr[0] = final_lst[i].ToString (); // arr[1] = re[i].ToString(); // li = new ListViewItem(arr); // listView2.Items.Add(li); //} temp t = new temp(); Dictionary<List<int>, List<string>> newdic = new Dictionary<List<int>, List<string>>(); newdic=t.reasonC(textBox2.Text.ToString ()); foreach (KeyValuePair<List<int>, List<string>> kvp in newdic.OrderBy(key => key.Key )) { for (int i = 0, j = 0; i < kvp.Key.Count && j < kvp.Value.Count ; i++, j++) { arr[1] = kvp.Key[i].ToString(); arr[0] = kvp.Value[j].ToString(); li = new ListViewItem(arr); listView2.Items.Add(li); } } //treeView2.ExpandAll(); //treeView3.ExpandAll(); //button16_Click1(null, null); }
private static void GetEnumValuesAndNames(IEdmEnumType enumType, ref ulong[] values, ref string[] names, bool getValues, bool getNames) { Dictionary<string, ulong> dict = new Dictionary<string, ulong>(); foreach (var member in enumType.Members) { EdmIntegerConstant intValue = member.Value as EdmIntegerConstant; if (intValue != null) { dict.Add(member.Name, (ulong)intValue.Value); } } Dictionary<string, ulong> sortedDict = dict.OrderBy(d => d.Value).ToDictionary(d => d.Key, d => d.Value); values = sortedDict.Select(d => d.Value).ToArray(); names = sortedDict.Select(d => d.Key).ToArray(); }
/// <summary> /// /// </summary> /// <param name="xmlSource"></param> /// <param name="logger"> </param> /// <param name="format">must include "{LineNo}" for Line Number spot</param> /// <param name="ignoreElements"> </param> /// <returns></returns> public string TagXmlElements(string xmlSource, Action<string> logger, string format, IEnumerable<string> ignoreElements) { var prefixXOnceList = new List<string>(); format = format.Replace(LineNumberFormatTag, "{0}"); var frameworkElements = new AssemblyHelper() .GetFrameworkElements().Select(fe => fe.Name).ToList(); StringBuilder output = new StringBuilder(); XmlWriterSettings ws = new XmlWriterSettings(); XmlWriter writer = null; var q = this.TraverseTree(xmlSource); bool isFirstElement = true; // Create an XmlReader using (XmlTextReader reader = new XmlTextReader(new StringReader(xmlSource))) { ws.ConformanceLevel = ConformanceLevel.Auto; using (writer = XmlWriter.Create(output, ws)) { // Parse the file and display each of the nodes. while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: //writer.WriteAttributes(reader, false); var eName = reader.Name; if (isFirstElement) { isFirstElement = false; if (!_validFirstElement.Contains(eName)) { logger(string.Format("Not tagging file with first Element: {0}", eName)); return xmlSource; } } var hasValue = !reader.IsEmptyElement; var currentNode = q.Dequeue(); //nodes may have more elements than reader shows, resync if needed int maxTries = 15; while (currentNode.Name != eName && (currentNode = q.Dequeue()) != null && maxTries-- > 0) { } if (currentNode == null || maxTries == 0) { throw new InvalidOperationException("Can't sync to xaml. aborting."); } var attributes = new Dictionary<string, string>(); for (int i = 0; i < reader.AttributeCount; ++i) { reader.MoveToNextAttribute(); attributes.Add(reader.Name, reader.Value); } string xmlns = null; if (attributes.ContainsKey("xmlns")) { xmlns = attributes["xmlns"]; attributes.Remove("xmlns"); } //xmlns:cfx if (eName.Contains(":")) { var split = eName.Split(':'); var extraNamespace = "xmlns:" + split[0]; if (xmlns == null && attributes.ContainsKey(extraNamespace)) { xmlns = attributes[extraNamespace]; attributes.Remove(extraNamespace); } writer.WriteStartElement(split[0], split[1], xmlns); } else { writer.WriteStartElement(eName, xmlns); } foreach (var attribute in attributes.OrderBy(pair => pair.Key.StartsWith("xmlns") ? 0 : 1)) //put the xmlns first to get the proper output { //for (int i = 0; i < reader.AttributeCount; ++i) //{ // reader.MoveToNextAttribute(); var name = attribute.Key; if (this._requiresXPrefix.Contains(name) && !prefixXOnceList.Contains(name)) { prefixXOnceList.Add(name); name = "x:" + name; } if (name.Contains(":")) { var split = name.Split(':'); writer.WriteAttributeString(split[0], split[1], null, attribute.Value); } else { writer.WriteAttributeString(name, attribute.Value); } } if (frameworkElements.Contains(eName) && !ignoreElements.Contains(eName)) { bool hasTag = reader.GetAttribute("Tag") != null || (currentNode.ChildNodes.Cast<XmlNode>()) .Any(n => n.Name == eName + ".Tag"); if (!hasTag) writer.WriteAttributeString("Tag", string.Format(format, reader.LineNumber.ToString())); } if (!hasValue) { writer.WriteEndElement(); } break; case XmlNodeType.Text: writer.WriteString(reader.Value); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(reader.Name, reader.Value); break; case XmlNodeType.Comment: writer.WriteComment(reader.Value); break; case XmlNodeType.EndElement: writer.WriteFullEndElement(); break; } } } } XDocument doc = XDocument.Parse(output.ToString()); return doc.ToString(); }
private Dictionary<object, object> initXValues(ResultPage page, List<ResultCell[]> XDimensions) { Dictionary<object, object> result = new Dictionary<object, object>(); bool hasNVD3Pie = Model.Elements.Exists(i => i.SerieDefinition == SerieDefinition.NVD3Serie && i.Nvd3Serie == NVD3SerieDefinition.PieChart && i.PivotPosition == PivotPosition.Data); bool orderAsc = true; foreach (var dimensions in XDimensions) { //One value -> set the raw value, several values -> concat the display value if (dimensions.Length == 1) { if (!dimensions[0].Element.IsEnum && dimensions[0].Element.AxisUseValues && !hasNVD3Pie) { result.Add(dimensions, dimensions[0].Value); } else { result.Add(dimensions, dimensions[0].ValueNoHTML); } } else result.Add(dimensions, Helper.ConcatCellValues(dimensions, ",")); if (dimensions.Length > 0 && dimensions[0].Element.SortOrder.Contains(SortOrderConverter.kAutomaticDescSortKeyword)) orderAsc = false; } return orderAsc ? result.OrderBy(i => i.Value).ToDictionary(i => i.Key, i => i.Value) : result.OrderByDescending(i => i.Value).ToDictionary(i => i.Key, i => i.Value); }
private string CalculateAuthSignature(Dictionary<string, string> parameters) { var sorted = parameters.OrderBy(p => p.Key); StringBuilder sb = new StringBuilder(ApiSecret); foreach (KeyValuePair<string, string> pair in sorted) { sb.Append(pair.Key); sb.Append(pair.Value); } string signature = UtilityMethods.MD5Hash(sb.ToString()); return signature; }
public void GeneratePLTS() { int i, j, m, k; uint eidcount = 10; uint sidbegin; uint sid; uint layernum; uint current; uint Allsnum = 0; HashSet<uint> tmpeset = new HashSet<uint>(); Queue<uint> generatelts = new Queue<uint>(); Dictionary<uint, uint> tmpdic = new Dictionary<uint,uint>(); List<KeyValuePair<uint,uint>> tmplist; Random rd = new Random((int)System.DateTime.Today.Ticks); generatelts.Enqueue(1); string path1 = "./test/Lts1.txt"; string path2 = "./test/Lts2.txt"; string path3 = "./test/evt.txt"; string path4 = "./test/allsnum.txt"; StreamWriter [] sw = new StreamWriter[2]; sw[0] = new StreamWriter(path1, true); sw[1] = new StreamWriter(path2, true); StreamWriter sw2 = new StreamWriter(path3, true); StreamWriter sw3 = new StreamWriter(path4, true); for (i = 0; i < LTSnum; i++) { Allsnum++; layernum = (uint)(Math.Pow(2, beginsynlayer)*2 - 1); for (j = 0; j < layernum; j++) { current = generatelts.Dequeue(); //layernum = layernum * 2; sidbegin = current * 2; for (m = 0; m < 2; 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); 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); } } 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); 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); } } 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(31, 51); } tmpeset.Add(eidcount); if (!this.eventlist.Contains(eidcount)) this.eventlist.Add(eidcount); //sw[i].Write(eidcount); } } tmpdic.Add(eidcount, sid); //sw[i].Write(" "); //sw[i].Write(sid); } tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value); tmplist = tmpdic.ToList(); for(m = 0; m < tmplist.Count; m++){ sw[i].Write(tmplist[m].Key); sw[i].Write(" "); sw[i].Write(tmplist[m].Value); sw[i].Write(" "); } tmpeset.Clear(); tmpdic.Clear(); sw[i].Write("\n"); } else { sid = sidbegin; generatelts.Enqueue(sid); Allsnum++; if(i == 0) eidcount = (uint)rd.Next(11, 31); else eidcount = (uint)rd.Next(31, 51); sw[i].Write(eidcount); sw[i].Write(" "); sw[i].Write(sid); sw[i].Write(" 0 1 "); for (m = 1; m < 4; m++) { sid = sidbegin + (uint)m; generatelts.Enqueue(sid); Allsnum++; eidcount = (uint)rd.Next(0, 11); if (!tmpeset.Contains(eidcount)) { //sw[i].Write(eidcount); tmpeset.Add(eidcount); if (!this.eventlist.Contains(eidcount)) this.eventlist.Add(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); } tmpdic.Add(eidcount, sid); //sw[i].Write(" "); //sw[i].Write(sid); } tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value); tmplist = tmpdic.ToList(); for(m = 0; m < tmplist.Count; m++){ sw[i].Write(tmplist[m].Key); sw[i].Write(" "); sw[i].Write(tmplist[m].Value); sw[i].Write(" "); } tmpeset.Clear(); tmpdic.Clear(); sw[i].Write("\n"); } } while (generatelts.Count > 0) { sw[i].Write("\n"); generatelts.Dequeue(); } sw[i].Flush(); sw[i].Close(); generatelts.Clear(); generatelts.Enqueue(1); } for (k = 0; k < this.eventlist.Count; k++) { sw2.Write(this.eventlist[k]); sw2.Write(" "); } sw2.Flush(); sw2.Close(); sw3.Write(Allsnum); sw3.Write("\n"); sw3.Flush(); sw3.Close(); }
public static Dictionary<int, long> SortVotes(Dictionary<long, int> dic) { Dictionary<int, long> res = new Dictionary<int, long>(); foreach (var item in dic.OrderBy(i => i.Value)) { if (!res.ContainsKey(item.Value)) { res.Add(item.Value, item.Key); } else { if (item.Key > res[item.Value]) { res[item.Value] = item.Key; } } } // Print resulting Dictionary //Console.WriteLine("SORTED VOTES:"); //foreach (int i in res.Keys) //{ // Console.WriteLine(i + " => " + res[i]); //} return res; }
private void LoadToolStripMenuItemClick(object sender, EventArgs e) { var dats = new Dictionary<string, string>(); bool exists = System.IO.Directory.Exists(Application.StartupPath + @"\mob lists"); if (!exists) System.IO.Directory.CreateDirectory(Application.StartupPath + @"\mob lists"); var openFile = new OpenFileDialog(); openFile.Filter = @"mob files (*.xml)|*.xml"; openFile.InitialDirectory = Application.StartupPath + @"\mob lists"; openFile.Title = @"select a mob list file"; switch (openFile.ShowDialog()) { case DialogResult.OK: var doc = XDocument.Load(openFile.FileName); if (doc.Root == null) return; foreach (var xml in doc.Root.Elements()) { dats.Add(xml.Attribute("id").Value, xml.Attribute("name").Value); } SelectedTargets.Items.Clear(); foreach (var entry in dats.OrderBy(key => key.Value)) { SelectedTargets.Items.Add(entry.Key).SubItems.Add(entry.Value); } break; } }
private string CalculateAuthSignature(Dictionary<string, string> parameters) { #if !SILVERLIGHT var sorted = new SortedList<string, string>(); foreach (var pair in parameters) { sorted.Add(pair.Key, pair.Value); } #else var sorted = parameters.OrderBy(p => p.Key); #endif var sb = new StringBuilder(ApiSecret); foreach (var pair in sorted) { sb.Append(pair.Key); sb.Append(pair.Value); } return UtilityMethods.MD5Hash(sb.ToString()); }
public string GenerateCreateTableSQL(PDFInfo info, Dictionary<string, PDFField> fields) { string formname = info.Title.Replace(" ", "_"); StringBuilder sb = new StringBuilder(); sb.Append("USE [XXXX]"); sb.Append("\n"); sb.Append("GO"); sb.Append("\n"); sb.Append("SET ANSI_NULLS ON"); sb.Append("\n"); sb.Append("GO"); sb.Append("\n"); sb.Append("SET QUOTED_IDENTIFIER ON "); sb.Append("\n"); sb.Append("GO "); sb.Append("\n"); sb.Append("CREATE TABLE [dbo].[" + formname + "]( "); sb.Append("\n"); sb.Append("[Id] [uniqueidentifier] NOT NULL, "); foreach (KeyValuePair<string, PDFField> field in fields.OrderBy(p => p.Key)) { sb.Append("[" + field.Key.Replace(" ", "_") + "] [nvarchar](500) NULL, "); sb.Append("\n"); } sb.Append("\n"); sb.Append("CONSTRAINT [PK_" + formname + "] PRIMARY KEY CLUSTERED "); sb.Append("\n"); sb.Append("( "); sb.Append("\n"); sb.Append("[Id] ASC "); sb.Append("\n"); sb.Append(")WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] "); sb.Append("\n"); sb.Append(") ON [PRIMARY] "); sb.Append("\n"); sb.Append("GO "); sb.Append("\n"); sb.Append("ALTER TABLE [dbo].[" + formname + "] ADD CONSTRAINT [DF_" + formname + "_Id] DEFAULT (newid()) FOR [Id] "); sb.Append("\n"); sb.Append("GO"); sb.Append("\n"); return sb.ToString(); }