Example #1
0
        private void Form1_Load_1(object sender, EventArgs e)
        {
            var source = new Dictionary<string, uint>();
            source.Add("F1", 0x70);
            source.Add("F2", 0x71);
            source.Add("F3", 0x72);
            source.Add("F4", 0x73);
            source.Add("F5", 0x74);
            source.Add("F6", 0x75);
            source.Add("F7", 0x76);
            source.Add("F8", 0x77);
            source.Add("F9", 0x78);
            source.Add("F10", 0x79);
            source.Add("F11", 0x80);
            source.Add("F12", 0x81);

            this.mana_hotkey.DataSource = source.ToList();
            this.mana_hotkey.DisplayMember = "Key";
            this.mana_hotkey.ValueMember = "Value";

            this.light_heal_hotkey.DataSource = source.ToList();
            this.light_heal_hotkey.DisplayMember = "Key";
            this.light_heal_hotkey.ValueMember = "Value";

            this.intense_heal_hotkey.DataSource = source.ToList();
            this.intense_heal_hotkey.DisplayMember = "Key";
            this.intense_heal_hotkey.ValueMember = "Value";
        }
        private Dictionary<string, double> weightVector; //Implemented as a map since it is simpler

        #endregion Fields

        #region Constructors

        public AveragedPerceptron(string category, List<Dictionary<string, int>> docsOfCategory, List<Dictionary<string, int>> docsNotOfCat,
							 double learningRate, int iterations, double bias, ISet<string> vocabulary)
        {
            if (learningRate <= 0 || learningRate >= 1)
                throw new ArgumentOutOfRangeException("0 < learningRate < 1 must be satisfied");

            this.category = category;
            this.learningRate = learningRate;
            this.bias = bias;
            int trainingSize = docsNotOfCat.Count + docsOfCategory.Count;

            //Initialize the weightvectors
            weightVector = new Dictionary<string, double>();
            foreach (var word in vocabulary)
            {
                weightVector.Add(word, 0);
            }
            averageWeightVector = new Dictionary<string, double>(weightVector);

            for (int i = 0; i < iterations; i++)
            {
                //Learn from training data
                foreach (var doc in docsOfCategory)
                {
                    this.Learn(true, doc, i, iterations, trainingSize);
                }
                foreach (var doc in docsNotOfCat)
                {
                    this.Learn(false, doc, i, iterations, trainingSize);
                }
            }
            List<KeyValuePair<string, double>> weightList = weightVector.ToList();
            weightList.Sort((firstPair, nextPair) => { return firstPair.Value.CompareTo(nextPair.Value); });
        }
 static void ShowBeautyNumber(string line)
 {
     line = line.ToLower();
     string pattern = "[^a-z]";
     string replacement = "";
     Regex rgx = new Regex(pattern);
     string resultStr = rgx.Replace(line, replacement);
     Dictionary<char, int> myMap = new Dictionary<char, int>();
     foreach(char ch in resultStr){
         if(!myMap.ContainsKey(ch)){
             myMap.Add(ch,0);
             }
             myMap[ch] += 1;
         }
     List<KeyValuePair<char, int>> myList = myMap.ToList();
     myList.Sort((firstPair,nextPair) =>{
         return -firstPair.Value.CompareTo(nextPair.Value);
         });
     int beauty = 26;
     int result = 0;
     foreach(KeyValuePair<char, int> itm in myList){
         result += itm.Value*beauty;
         beauty--;
     }
     Console.WriteLine(result);
 }
        static void Main(string[] args)
        {
            Console.WriteLine("String :");
            string text = Console.ReadLine();

            List<string> checkedWords = new List<string>();
            string[] words = text.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
            Dictionary<string, int> count = new Dictionary<string, int>();
            for (int i = 0; i < words.Length; i++)
            {
                string word = words[i];
                if (!checkedWords.Contains(word))
                {
                    count.Add(word, words.Count(x => x == word));
                    checkedWords.Add(word);
                }
            }
            List<KeyValuePair<string, int>> sorted = count.ToList();

            sorted.Sort((x, y) => { return y.Value.CompareTo(x.Value); });
            foreach (var item in sorted)
            {
                Console.WriteLine("{0} - {1}", item.Key, item.Value);
            }
        }
Example #5
0
        static void Main(string[] args)
        {
            Dictionary<char, int> symbols = new Dictionary<char, int>();

            string text = Console.ReadLine();

            for (int i = 0; i < text.Length; i++)
            {
                char currentChar = Convert.ToChar(text[i]);

                if (!symbols.ContainsKey(text[i]))
                {
                    symbols[currentChar] = 0;
                }

                symbols[currentChar]++;
            }

            var orderedSymbols = symbols.ToList();
            orderedSymbols.Sort(delegate(KeyValue<char, int> c1, KeyValue<char, int> c2) { return c1.Key.CompareTo(c2.Key); });

            foreach (var symbol in orderedSymbols)
            {
                Console.WriteLine(symbol + " time/s");
            }
        }
        private IList<KeyValuePair<string, string>> GetProductList()
        {
            Dictionary<string, string> dicProductList = new Dictionary<string, string>();

            //橡膠
            dicProductList.Add("JRU-橡膠", "81");
            //黃金
            dicProductList.Add("JAU-黃金", "11");
            //小黃金
            dicProductList.Add("JAM-小黃金", "16");
            //白銀
            dicProductList.Add("JSV-白銀", "12");
            //白金
            dicProductList.Add("JPL-//白金", "13");
            //小白金
            dicProductList.Add("JPM-小白金", "17");
            //鈀金
            dicProductList.Add("JPA-鈀金", "14");
            //汽油
            dicProductList.Add("JGL-汽油", "31");
            //燃油
            dicProductList.Add("JKE-燃油", "32");
            //原油
            dicProductList.Add("JCO-原油", "33");

            return dicProductList.ToList();
        }
        public static void SetExtractOutput(DependencyObject dependencyObject, Dictionary<string, string> list)
        {
            MainWindow mainWindow = MainContext.GetMainWindow(dependencyObject);
            LayoutAnchorable documentPane = mainWindow.MainDockingManager.Layout.Descendents()
                          .OfType<LayoutAnchorable>()
                          .FirstOrDefault(c => c.ContentId == "OutputContent");

            if (documentPane != null)
            {
                if (documentPane.IsAutoHidden)
                {
                    documentPane.ToggleAutoHide();
                }
                var content = documentPane.Content as OutputPageUserControl;
                if (content != null)
                {
                    LayoutDocumentPane panes =
                        content.OutputDockingManager.Layout.Descendents().OfType<LayoutDocumentPane>().FirstOrDefault();

                    for (; panes.ChildrenCount > 0; )
                    {
                        LayoutContent pane = panes.Children[0];
                        pane.Close();
                    }

                    foreach (var pair in list.ToList())
                    {
                        var outputContentUserControl = new OutputContentUserControl();
                        outputContentUserControl.ContentTextEditor.Text = pair.Value;
                        UtilityManager.CreateTab(content.OutputDockingManager, outputContentUserControl, pair.Key);
                    }
                }
            }
        }
Example #8
0
		public static JsonArray GetPoiInformation(Location userLocation, int numberOfPlaces)
		{
			if (userLocation == null)
				return null;

			var pois = new List<JsonObject> ();

			for (int i = 0; i < numberOfPlaces; i++)
			{
				var loc = GetRandomLatLonNearby (userLocation.Latitude, userLocation.Longitude);

				var p = new Dictionary<string, JsonValue>(){
					{ "id", i.ToString() },
					{ "name", "POI#" + i.ToString() },
					{ "description", "This is the description of POI#" + i.ToString() },
					{ "latitude", loc[0] },
					{ "longitude", loc[1] },
					{ "altitude", 100f }
				};


				pois.Add (new JsonObject (p.ToList()));
			}

			var vals = from p in pois select (JsonValue)p;

			return new JsonArray (vals);
		}
Example #9
0
        static void Main(string[] args)
        {
            var matches = GetWords();

            Dictionary<string, int> wordOccurance = new Dictionary<string, int>();

            foreach (var word in matches)
            {
                string strWord = word.ToString();
                if (wordOccurance.ContainsKey(strWord))
                {
                    wordOccurance[strWord] += 1;
                }
                else
                {
                    wordOccurance.Add(strWord, 1);
                }
            }

            List<KeyValuePair<string, int>> wordPairs = wordOccurance.ToList();
            wordPairs.Sort((x, y) => x.Value.CompareTo(y.Value));

            foreach (var entry in wordPairs)
            {
                Console.WriteLine("{0}: {1}", entry.Key, entry.Value);
            }

        }
Example #10
0
        public List<KeyValuePair<string, double>> RankedResults()
        {
            List<Document> documents = new List<Document>();
            HashSet<string> dataSet = new HashSet<string>();
            foreach (var result in results)
            {
                Document d = new Document(result);
                documents.Add(d);
                foreach (var term in d.tokens()){
                    dataSet.Add(term);
                }
            }
            //Build Document Vectors
            Dictionary<string, Vector> documentVectors = new Dictionary<string, Vector>();
            foreach (var document in documents)
            {
                documentVectors.Add(document.ToString(), new Vector(dataSet, document));
            }
            //Build Query Vector
            Query query = new Query(queryString);
            Vector queryVector = new Vector(dataSet, query);

            Dictionary<string, double> relevance = new Dictionary<string, double>();
            foreach (var documentVector in documentVectors)
            {
                relevance.Add(documentVector.Key, Vector.GetSimilarityScore(queryVector, documentVector.Value));
            }
            //Sort result by most relevant
            List<KeyValuePair<string, double>> myList = relevance.ToList();
            return myList;
        }
    public static void Main()
    {
        string text = @"C# is not C++, not PHP and not Delphi! Write a program that extracts from a given text all palindromes, e.g. ""ABBA"", ""lamal"", ""exe"".";
        //Console.WriteLine("Please enter your text:");
        //string text = Console.ReadLine();

        string regex = @"[A-Z]+";

        Dictionary<string, int> wordOccurrences = new Dictionary<string, int>();
        
        MatchCollection matches = Regex.Matches(text, regex, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);

        foreach (Match match in matches)
        {
            if (wordOccurrences.ContainsKey(match.Value))
            {
                wordOccurrences[match.Value]++;
            }
            else
            {
                wordOccurrences.Add(match.Value, 1);
            }
        }

        // var sortedDictionary = (from entry in wordOccurrences orderby entry.Key ascending select entry).ToDictionary(pair => pair.Key, pair => pair.Value);
        List<KeyValuePair<string, int>> sortedDictionary = wordOccurrences.ToList();
        
        sortedDictionary.Sort((x, y) => x.Key.CompareTo(y.Key));

        foreach (KeyValuePair<string, int> wordEntry in sortedDictionary)
        {
            Console.WriteLine("{0}: {1}", wordEntry.Key, wordEntry.Value);
        }
    }
        /// <summary>
        /// Json Çıktısı Olarak AppData İçindeki İlleri Servisten Yayınlıyoruz
        /// </summary>
        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "application/json";

            Dictionary<int,string> iller = new Dictionary<int, string>();

            using (StreamReader stramreader = new StreamReader(context.Server.MapPath("App_Data\\veri.txt")))
            {
                while (stramreader.Peek()>=0)
                {
                    try
                    {
                        string[] satir = stramreader.ReadLine().ToString().Split('	');
                        iller.Add(int.Parse(satir[0].Trim()), satir[1]);
                    }
                    catch (Exception)
                    {

                    }
                }

            }

            context.Response.Write(JsonConvert.SerializeObject(iller.ToList()));
        }
        public IronPythonComposablePart(IronPythonTypeWrapper typeWrapper, IEnumerable<Type> exports, IEnumerable<KeyValuePair<string, IronPythonImportDefinition>> imports)
        {
            _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)}
                                   };

                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);
            }
        }
Example #14
0
 void onBonusesLoaded(Dictionary<long, string> difficultyIds)
 {
     List<KeyValuePair<long, string>> list = difficultyIds.ToList();
     list.Sort((first, second) => first.Key.CompareTo(second.Key));
     foreach (KeyValuePair<long, string> pair in list)
         addButton(pair);
 }
Example #15
0
        protected void btnSubmit_Click(object sender, EventArgs e)
        {
            tableColumns = (Dictionary<string, List<DB.Column>>)Session["tableColumns"];
            if (null == tableColumns) return;
            var dbo = new DB.DBCalls();

            tableColumns.ToList().ForEach(table =>
            {
                var query = "alter table [" + client + "].[" + table.Key + "] add ";
                table.Value.ForEach(column =>
                {
                    query += "[" + column.ColumnName + "] " + column.DataType.ToString();
                    if ((column.DataType == System.Data.SqlDbType.VarChar) || (column.DataType == System.Data.SqlDbType.NVarChar) || (column.DataType == System.Data.SqlDbType.Char) || (column.DataType == System.Data.SqlDbType.Char) || (column.DataType == System.Data.SqlDbType.NChar))
                    {
                        query += "(" + column.Length.ToString() + ")";
                    }
                    query += (column.IsNullable) ? " null " : " not null ";
                    query +=  (string.IsNullOrEmpty(column.DefaultValue)) ? "" : " default '" + column.DefaultValue + "'";
                    query += ", ";
                });
                query = query.Remove(query.LastIndexOf(","), 2);
                try
                {
                    dbo.ExecuteString(query);
                }
                catch (System.Data.SqlClient.SqlException sqlE)
                {
                }
            });
        }
Example #16
0
        public override Dictionary<string, double> SuggestNItems(Dictionary<string, SuggestorCollection> collections, SuggestorCollection compareCollection, int n)
        {
            if (compareCollection.CollectionLines.Count == 0) return null;

            Dictionary<string, double> itemAggregation = new Dictionary<string, double>();

            // Find top similar collections
            Dictionary<SuggestorCollection, double> topCollections = SuggestNCollections(collections.Values.ToList(), compareCollection, n);

            foreach (SuggestorCollection collection in topCollections.Keys)
            {
                foreach (string itemNo in collection.CollectionLines.Keys)
                {
                    if (compareCollection.CollectionLines.ContainsKey(itemNo)) continue; // Ignore items that are already in basket
                    if (!(itemAggregation.ContainsKey(itemNo))) itemAggregation.Add(itemNo, 1);
                    itemAggregation[itemNo]++;
                    //itemAggregation[itemNo] += topInvoices[invoice] * 1.0;
                }
            }

            List<KeyValuePair<string, double>> itemAggregationList = itemAggregation.ToList();
            // Sort dictionary by value
            itemAggregationList.Sort((firstPair, nextPair) => { return firstPair.Value.CompareTo(nextPair.Value); });
            itemAggregationList.Reverse();
            itemAggregation = itemAggregationList.ToDictionary(pair => pair.Key, pair => pair.Value);
            return itemAggregation;
        }
Example #17
0
        public List<KeyValuePair<int, float>> Ensenble(List<IList<Tuple<int, float>>> list)
        {
            var novaList = new Dictionary<int, float>();

            //Vamos criar uma nova lista com o score junto
            foreach (IList<Tuple<int, float>> aLista in list)
            {
                foreach (Tuple<int, float> item in aLista)
                {

                    if (novaList.ContainsKey(item.Item1))
                    {
                        if (novaList[item.Item1] < item.Item2)
                        {
                            novaList[item.Item1] = item.Item2;
                        }
                    }
                    else
                    {
                        novaList.Add(item.Item1, item.Item2);
                    }

                }

            }

            List<KeyValuePair<int, float>> listRetorno = novaList.ToList();

            listRetorno.Sort((firstPair, nextPair) =>
            {
                return nextPair.Value.CompareTo(firstPair.Value);
            });

            return listRetorno;
        }
        public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules()
        {
            var validationRules = new Dictionary<object, string>();
            var items = typeof(ValidationRules).GetFields().Select(f=> new KeyValuePair<object, string>(f.GetValue(null), f.Name));
            foreach (var item in items)
            {
                validationRules.Add(item.Key, item.Value);
            }

            var unFoundValidationRules = new List<object>();

            foreach(var ruleSet in ValidationRuleSet.GetEdmModelRuleSet(new Version(4, 0)))
            {
                if (validationRules.ContainsKey(ruleSet))
                {
                    validationRules.Remove(ruleSet);
                }
                else
                {
                    unFoundValidationRules.Add(validationRules);
                }
            }

            unFoundValidationRules.Should().HaveCount(0);

            // The 4 remaining rules are deprecated:
            // ComplexTypeMustContainProperties
            // OnlyEntityTypesCanBeOpen
            // ComplexTypeInvalidPolymorphicComplexType
            // ComplexTypeInvalidAbstractComplexType
            validationRules.ToList().Should().HaveCount(4);
        }
Example #19
0
 public void CreateFlowWithAssignId(Guid flowId, string flowName, User originator, string title, Dictionary<string, string> args = null, string comment = null)
 {
     var trans = TransactionManager.BeginTransaction();
     try
     {
         var flow = new Flow();
         flow.FlowStatus = FlowStatus.Instance;
         var flowType = _flowTypeRepository.GetByTypeName(flowName);
         if (flowType == null)
             throw new Exception(string.Format("{0}的流程类型不存在", flowName));
         flow.FlowType = flowType;
         flow.Id = flowId;
         flow.Title = title;
         args = args ?? new Dictionary<string, string>();
         args.ToList().ForEach(o => flow.FlowDataFields.Add(new FlowDataField { Name = o.Key, Value = o.Value }));
         flow.RecordDescription.CreateBy(originator);
         flow.UserOfFlowAdmin = originator;
         var history = new FlowHistory()
         {
             Comment = comment,
             Action = "提交流程",
             Stage = "发起流程"
         };
         history.RecordDescription.CreateBy(originator);
         flow.FlowHistories.Add(history);
         _flowRepository.Save(flow);
         trans.Commit();
     }
     catch (Exception)
     {
         trans.Rollback();
         throw;
     }
 }
        private void _convertIntermediateResultsToFinal(BaseSentenceAlgorithmData result, int parentId, Dictionary<int, PredicatePartsStageHelperObject> intermediateResult, BaseSentenceAlgorithmData sourceData, int rootId, string rootType)
        {
            _recursionLevel++;

            var currentResults = intermediateResult.ToList().FindAll(x => x.Value.Parent == parentId);

            if (currentResults.Count > 0)
            {
                foreach (var currentResult in currentResults)
                {
                    var currentSentenceElement = result.Sentence.Elements.Find(x => x.Id == currentResult.Key);

                    if (_recursionLevel == 1)
                    {
                        rootId = currentResult.Key;
                        rootType = sourceData.HelperData.GetRowByGUID(currentSentenceElement.GUID).Field<string>(HelperDataPredicateCorrectionSourceType.Name);
                    }

                    var predicatePartType = currentResult.Value.Type.ToString();

                    result.HelperData.AddOrUpdateCustomRow(currentSentenceElement.GUID, currentSentenceElement.Id, currentSentenceElement.Order, rootId, currentResult.Value.Parent, predicatePartType,  currentResult.Value.Level, rootType);

                    var newParentID = currentResult.Key;

                    _convertIntermediateResultsToFinal(result, newParentID, intermediateResult, sourceData, rootId, rootType);
                    _recursionLevel--;
                }
            }
        }
        static void Main()
        {
            string text = String.Empty;
            using (StreamReader sr = new StreamReader(@"..\..\TextFile.txt"))
            {
                text = sr.ReadToEnd().ToLower();
            }

            var matches = Regex.Matches(text, @"\w+");

            Dictionary<string, int> occurances = new Dictionary<string, int>();

            foreach (var word in matches)
            {
                string keyWord = word.ToString();
                if (!occurances.Keys.Contains(keyWord))
                {
                    occurances.Add(keyWord, 1);
                }
                else
                {
                    occurances[keyWord]++;
                }
            }

            List<KeyValuePair<string, int>> pairs = occurances.ToList();
            pairs.Sort((x, y) => x.Value.CompareTo(y.Value));

            foreach (var pair in pairs)
            {
                Console.WriteLine("{0} -> {1}", pair.Key, pair.Value);
            }
        }
Example #22
0
        public void WithArguments(Dictionary<string, object> args)
        {
            if (args == null)
                return;

            Arguments = args.ToList();
        }
        public static string HttpPost(string uri, Dictionary<string, string> parameters,
            List<KeyValuePair<string, string>> sensitiveStrings = null)
        {
            var asList = parameters.ToList();

            return HttpPost(uri, asList, sensitiveStrings);
        }
        static void Main(string[] args)
        {
            Console.Write("Enter array size: ");
            int size = int.Parse(Console.ReadLine());

            int[] array = new int[size];

            Console.WriteLine();
            for (int i = 0; i < size; i++)
            {
                Console.Write("Enter array[{0}]: ", i);
                array[i] = int.Parse(Console.ReadLine());
            }

            Dictionary<int, int> occurences = new Dictionary<int, int>();
            for(int i = 0; i < size; i ++)
            {
                if(occurences.ContainsKey(array[i]))
                {
                    occurences[array[i]]++;
                }
                else
                {
                    occurences.Add(array[i], 1);
                }
            }

            List<KeyValuePair<int, int>> sorted = occurences.ToList();
            sorted.Sort((x, y) => x.Value.CompareTo(y.Value));
            Console.WriteLine("The most frequent number is {0} -> {1} times",
                sorted.Last().Key, sorted.Last().Value);
            Console.ReadLine();
        }
Example #25
0
        /// <summary>
        /// Merges the values.
        /// </summary>
        /// <param name="configValues">The config values.</param>
        /// <param name="recipient">The recipient.</param>
        /// <returns></returns>
        protected Dictionary<string, object> MergeValues( Dictionary<string, object> configValues, CommunicationRecipient recipient )
        {
            Dictionary<string, object> mergeValues = new Dictionary<string, object>();

            configValues.ToList().ForEach( v => mergeValues.Add( v.Key, v.Value ) );

            if ( recipient != null )
            {
                if ( recipient.Person != null )
                {
                    mergeValues.Add( "Person", recipient.Person );
                }

                // Add any additional merge fields created through a report
                foreach ( var mergeField in recipient.AdditionalMergeValues )
                {
                    if ( !mergeValues.ContainsKey( mergeField.Key ) )
                    {
                        mergeValues.Add( mergeField.Key, mergeField.Value );
                    }
                }
            }

            return mergeValues;

        }
Example #26
0
		public override String run(CommandInfo cmdInfo, Bot bot) {
			String output = "Here are the items you have duplicates of:";
			dynamic json = Util.CreateSteamRequest(String.Format("http://api.steampowered.com/ITFItems_440/GetPlayerItems/v0001/?key=" + bot.apiKey + "&SteamID={0}&format=json",cmdInfo.getSteamid().ConvertToUInt64()),"GET");
		
			int limit = cmdInfo.getArg(0, 2);
			Dictionary<int, MutableInt> freq = new Dictionary<int, MutableInt>();
			foreach (dynamic i in json.result.items.item) {
				int defindex = i.defindex;
				if (freq.ContainsKey(defindex)) {
					freq[defindex].increment();
				} else {
					freq.Add(defindex, new MutableInt());
				}
			}

			List<KeyValuePair<int, MutableInt>> myList = freq.ToList();
			myList.Sort((firstPair,nextPair) =>
				{
					return firstPair.Value.CompareTo(nextPair.Value);
				}
			);
			
			foreach (KeyValuePair<int, MutableInt> entry in myList) {
				if (entry.Value.get() < limit) {
					break;
				}
				ItemInfo itemInfo = Util.getItemInfo(entry.Key);
				output += "\n" + itemInfo.getName() + " x" + entry.Value.get();
			}
			return output;
		}
        public static ControlKeyStates ToControlKeyState( this Console.ConsoleControlKeyStates state )
        {
            var map = new Dictionary<Console.ConsoleControlKeyStates, ControlKeyStates>
                          {
                              {ConsoleControlKeyStates.CapsLockOn, ControlKeyStates.CapsLockOn},
                              {ConsoleControlKeyStates.EnhancedKey, ControlKeyStates.EnhancedKey},
                              {ConsoleControlKeyStates.LeftAltPressed, ControlKeyStates.LeftAltPressed},
                              {ConsoleControlKeyStates.LeftCtrlPressed, ControlKeyStates.LeftCtrlPressed},
                              {ConsoleControlKeyStates.NumLockOn, ControlKeyStates.NumLockOn},
                              {ConsoleControlKeyStates.RightAltPressed, ControlKeyStates.RightAltPressed},
                              {ConsoleControlKeyStates.RightCtrlPressed, ControlKeyStates.RightCtrlPressed},
                              {ConsoleControlKeyStates.ScrollLockOn, ControlKeyStates.ScrollLockOn},
                              {ConsoleControlKeyStates.ShiftPressed, ControlKeyStates.ShiftPressed},
                          };

            ControlKeyStates controlKeyState = 0;
            map.ToList().ForEach(pair =>
                                     {
                                         if (0 != (pair.Key & state))
                                         {
                                             controlKeyState |= pair.Value;
                                         }
                                     });
            return controlKeyState;
        }
Example #28
0
        static void Main(string[] args)
        {            
            WriteHeader("Jedan objekat, klasika");

            var myCat = new Cat("Garfield");
            myCat.Walk();
            myCat.Talk();


            WriteHeader("Jedan objekat, oneliner");

            new Cat("Garfield").Walk().Talk();


            WriteHeader("Više objekata (znamo tip u compile time)");

            var animals = new List<Animal>
                              {
                                  new Cat("Garfield"), 
                                  new Dog("Locko"), 
                                  new Dog("Pajko")
                              };

            foreach (var animal in animals)
            {
                animal.Walk();
                animal.Talk();
            }


            WriteHeader("Više objekata, tip se određuje u runtime");

            var animalsNameType = new Dictionary<string, string>
                                      {
                                          {"Garfield", "Cat"},
                                          {"Locko", "Dog"},
                                          {"Pajko", "Dog"}
                                      };

            foreach (var pair in animalsNameType)
            {
                var animal = AnimalFactory.Create(pair.Value, pair.Key);

                animal.Walk();
                animal.Talk();
            }


            WriteHeader("Više objekata, tip se određuje u runtime, oneliner");

            animalsNameType.ToList().ForEach(
                    pair =>
                        AnimalFactory.Create(pair.Value, pair.Key)
                            .Walk()
                            .Talk()
                );
            
            Console.Read();
        }
		private static void WriteAnswer(Dictionary<City, int> liderCities)
		{
			using (var stream = Console.Out)
			{
				foreach (var res in liderCities.ToList().SortByNameCity())
					stream.WriteLine("{0} {1}", res.Key.Name, res.Value);
			}
		}
Example #30
0
 public static List<string> FindDuplicateFeeds(List<Dictionary<string,string>> list_dict_str)
 {
     var feedurls = new Dictionary<string, int>();
     foreach (var dict in list_dict_str)
         feedurls.IncrementOrAdd(dict["feedurl"]);
     var dupes = feedurls.ToList().FindAll(x => Convert.ToInt16(x.Value) > 1);
     return dupes.Select(x => x.Key).ToList();
 }