C# MongoCollection.FindAs方法代码示例

 private static void AddToDictionary(MongoCollection english)
 {
     Console.WriteLine("Enter word.");
     string word = Console.ReadLine();
     Console.WriteLine("Enter translation.");
     string translation = Console.ReadLine();
     if (!string.IsNullOrWhiteSpace(word) && !string.IsNullOrWhiteSpace(translation))
     {
         var query = Query.And(Query.EQ("Name", word));
         var filtered = english.FindAs<Word>(query);
         var count = filtered.Count();
         if (count == 0)
         {
             english.Insert(new Word(word, translation));
             Console.WriteLine("The word {0} is added.", word);
         }
         else
         {
             Console.WriteLine("The word {0} is already added.", word);
         }
     }
     else
     {
         Console.WriteLine("You enter null or empty string for word or translation. Please try again.");
     }
 }

 private static void ChangeTranslation(MongoCollection english)
 {
     Console.WriteLine("Enter word.");
     string word = Console.ReadLine();
     Console.WriteLine("Enter translation.");
     string translation = Console.ReadLine();
     if (!string.IsNullOrWhiteSpace(word) && !string.IsNullOrWhiteSpace(translation))
     {
         var query = Query.And(Query.EQ("Name", word));
         var filtered = english.FindAs<Word>(query);
         var count = filtered.Count();
         if (count > 0)
         {
             foreach (var item in filtered)
             {
                 var update = Update.Set("Translation", translation);
                 var queryId = Query.EQ("_id", item.Id);
                 english.Update(queryId, update);
                 Console.WriteLine("Translation of the word {0} is changed.", word);
             }
         }
         else
         {
             Console.WriteLine("There is no word {0}.", word);
         }
     }
     else
     {
         Console.WriteLine("You enter null or empty string for word or translation. Please try again.");
     }
 }

        public dynamic find(MongoCollection collection,object[] args)
        {
            Type type = args[0].GetType();

            if(type.Name.Contains("<>__AnonType")){

                PropertyInfo[] properties = type.GetProperties();
                Dictionary<string,object> dictionary = new Dictionary<string, object>();
                foreach(var property in properties)
                    dictionary[property.Name] = property.GetValue(args[0],null);

                var query = new QueryDocument(dictionary);
                var result = collection.FindAs<BsonDocument>(query);
                List<Entity> documents = new List<Entity>();

                if(result.Size() > 0)
                {
                    foreach(var entity in result)
                        documents.Add(new Entity(entity));
                }

                return documents;
            }
            throw new NotImplementedException("Only annonymous types are accepted for Queries.");
        }

 /// <summary>
 ///     ExportToFile
 /// </summary>
 /// <param name="currentDataViewInfo"></param>
 /// <param name="excelFileName"></param>
 /// <param name="exportType"></param>
 /// <param name="mongoCol"></param>
 public static void ExportToFile(DataViewInfo currentDataViewInfo,
     string excelFileName,
     EnumMgr.ExportType exportType,
     MongoCollection mongoCol)
 {
     MongoCursor<BsonDocument> cursor;
     //Query condition:
     if (currentDataViewInfo != null && currentDataViewInfo.IsUseFilter)
     {
         cursor = mongoCol.FindAs<BsonDocument>(
             QueryHelper.GetQuery(currentDataViewInfo.MDataFilter.QueryConditionList))
             .SetFields(QueryHelper.GetOutputFields(currentDataViewInfo.MDataFilter.QueryFieldList))
             .SetSortOrder(QueryHelper.GetSort(currentDataViewInfo.MDataFilter.QueryFieldList));
     }
     else
     {
         cursor = mongoCol.FindAllAs<BsonDocument>();
     }
     var dataList = cursor.ToList();
     switch (exportType)
     {
         case EnumMgr.ExportType.Excel:
             //ExportToExcel(dataList, ExcelFileName);
             GC.Collect();
             break;
         case EnumMgr.ExportType.Text:
             ExportToJson(dataList, excelFileName, MongoHelper.JsonWriterSettings);
             break;
         case EnumMgr.ExportType.Xml:
             break;
     }
     MongoHelper.OnActionDone(new ActionDoneEventArgs(" Completed "));
 }

 private int NewMethod(MongoCollection coll, string fbname)
 {
     var v = coll.FindAs<BsonDocument>(Query.Null).SetFields(fbname);
     Dictionary<BsonValue, string> results = new Dictionary<BsonValue, string>();
     foreach (var item in v)
     {
         BsonValue value;
         if (item.TryGetValue(fbname, out value))
         {
             string oldName = value.ToString();
             string newName = ReplayceName(oldName);
             if (oldName != newName)
             {
                 item.TryGetValue("_id", out value);
                 results.Add(value, newName);
             }
         }
     }
     foreach (var item in results)
     {
         BsonValue id = item.Key;
         string newName = item.Value;
         try
         {
             Query.EQ("_id", id);
             Update.Set(fbname, newName);
             coll.Update(Query.EQ("_id", id), Update.Set(fbname, newName), SafeMode.False);
         }
         catch (System.Exception ex)
         {
             LogWrapper.Error("renameErr:" + id + " newName" + newName, ex);
         }
     }
     return results.Count;
 }

        public static void FindDescriptionByBookName(MongoCollection dictonary, string bookName)
        {
            var searchQuery = Query.EQ("Name", bookName);

            var queryResult = dictonary.FindAs<Entry>(searchQuery);

            Console.WriteLine("Search");
            Console.WriteLine(new string('-', Console.WindowWidth - 5));

            foreach (var item in queryResult)
            {
                Console.WriteLine("Book Name: {0}, Transalation: {1}", item.Name, item.Translation);
            }
        }

 /// <summary>
 ///     运行
 /// </summary>
 /// <returns></returns>
 public override int Run()
 {
     _processCollection = (MongoCollection)PlugObj;
     if (RuntimeMongoDbContext.CollectionFilter.ContainsKey(_processCollection.Name))
     {
         var filter = RuntimeMongoDbContext.CollectionFilter[_processCollection.Name].QueryConditionList;
         Export(_processCollection.FindAs<BsonDocument>(QueryHelper.GetQuery(filter)).ToList(), _processCollection.Name);
     }
     else
     {
         Export(_processCollection.FindAllAs<BsonDocument>().ToList(), _processCollection.Name);
     }
     MessageBox.Show(_processCollection.Name);
     return Success;
 }

 private static void ShowTranslation(MongoCollection english)
 {
     Console.WriteLine("Enter word");
     string word = Console.ReadLine();
     if (!string.IsNullOrWhiteSpace(word))
     {
         var query = Query.And(Query.EQ("Name", word));
         var filtered = english.FindAs<Word>(query);
         var count = filtered.Count();
         if (count > 0)
         {
             Console.WriteLine("Translation of the word {0} is:", filtered.First().Name);
             Console.WriteLine(filtered.First().Translation);
         }
         else
         {
             Console.WriteLine("There is no word {0}.", word);
         }
     }
     else
     {
         Console.WriteLine("You enter null or empty string for word. Please try again.");
     }
 }

 /// <summary>
 /// Is Exist by Key
 /// </summary>
 /// <param name="mongoCol">Collection</param>
 /// <param name="KeyValue">KeyValue</param>
 /// <param name="Field">KeyField</param>
 /// <returns></returns>
 public static Boolean IsExistByKey(MongoCollection mongoCol, BsonValue KeyValue)
 {
     return mongoCol.FindAs<BsonDocument>(Query.EQ(KEY_ID, KeyValue)).Count() > 0;
 }

 public ApplicationDbContext(MongoCollection usersCollection, MongoCollection rolesCollection, MongoCollection clainsCollection, MongoCollection clientCollection)
     : base(usersCollection, rolesCollection, clainsCollection, clientCollection)
 {
     Clients = clientCollection.FindAs<IdentityClient>(null).ToList();
     Claims = clainsCollection.FindAs<IdentityClaim>(null).ToList();
 }

 /// <summary>
 /// 是否存在某个数据
 /// </summary>
 /// <param name="Field"></param>
 /// <param name="mongoCol"></param>
 /// <returns></returns>
 public static Boolean IsExistByField(MongoCollection mongoCol, BsonValue strKey, string Field = "_id")
 {
     return mongoCol.FindAs<BsonDocument>(Query.EQ(Field, strKey)).Count() > 0;
 }

        private int NewMethod2(MongoCollection coll)
        {
            var v = coll.FindAs<BsonDocument>(Query.Null);
            Dictionary<string, string> results = new Dictionary<string, string>();
            List<BsonDocument> list = new List<BsonDocument>();
            List<string> oldID = new List<string>();
            foreach (var item in v)
            {
                BsonValue value;
                if (item.TryGetValue("_id", out value))
                {
                    string oldName = value.ToString();
                    string newName = ReplayceName(oldName);
                    if (oldName != newName)
                    {
                        oldID.Add(oldName);
                        item["_id"] = newName;
                        list.Add(item);
                    }
                }
            }
            foreach (var item in list)
            {
                coll.Save(item);
            }

            foreach (var item in oldID)
            {
                coll.Remove(Query.EQ("_id", item));
            }
            return results.Count;
        }

        static List<Click> ListClicks(MongoCollection clicks, int minX = 0, int maxX = int.MaxValue, int minY = 0, int maxY = int.MaxValue)
        {
            var query = Query.And(Query.GTE("Location.X", minX), Query.GTE("Location.Y", minY), Query.LTE("Location.X", maxX), Query.LTE("Location.X", maxY));

            //This operation risks an exception if the element is not exactly a Click object (e.g. has an added field). To be safe, use BsonDocument as a type
            var filteredClicks = clicks.FindAs<Click>(query);
            int index = 0;

            var listedClicks = new List<Click>();

            foreach (var click in filteredClicks)
            {
                Console.WriteLine(index + ". " + click.ToString());
                index++;
                listedClicks.Add(click);
            }

            return listedClicks;
        }