private void createFilteredList(string search) { //generate objects to be layed out in the panel List <GameObject> knownSkills = SkillLibrary.Instance.getByListID(PlayerMotivator.Instance.getSkillBook()); skillList = new List <GameObject>(); OrderEnum pri = PlayerMotivator.Instance.GetPrimaryOrderEnum(); OrderEnum sec = PlayerMotivator.Instance.GetSecondaryOrderEnum(); foreach (GameObject skill in knownSkills) { BaseSkill component = skill.GetComponent <BaseSkill>(); // make sure that it has a baseSkill component, just in case if (component != null) { OrderEnum skillOrder = component.getOrder(); // and check if the object is of the right order, then add it to the list if (skillOrder == pri || skillOrder == sec || skillOrder == OrderEnum.none) { // Gets the name and searches it for any instances of the search string if (component.getName().ToLower().Contains(search.ToLower())) { skillList.Add(skill); } } } } }
private IQueryable <UserGroup> ApplyOrder(IQueryable <UserGroup> queryUserGroups, GroupFieldEnum orderField, OrderEnum order) { switch (orderField) { case GroupFieldEnum.name: if (order == OrderEnum.Ascending) { queryUserGroups = queryUserGroups.OrderBy(x => x.name); } else { queryUserGroups = queryUserGroups.OrderByDescending(x => x.name); } break; case GroupFieldEnum.description: if (order == OrderEnum.Ascending) { queryUserGroups = queryUserGroups.OrderBy(x => x.description); } else { queryUserGroups = queryUserGroups.OrderByDescending(x => x.description); } break; default: queryUserGroups = queryUserGroups.OrderBy(x => x.name); break; } return(queryUserGroups); }
public bool BinaryContains(Document document, OrderEnum listOrder) { bool returnValue = false; switch (listOrder) { case OrderEnum.IDOrder: if (BinarySearch(document, OrderEnum.IDOrder) > 0) { returnValue = true; } break; case OrderEnum.TitleOrder: if (BinarySearch(document, OrderEnum.TitleOrder) > 0) { returnValue = true; } break; case OrderEnum.MatchOrder: if (BinarySearch(document, OrderEnum.MatchOrder) > 0) { returnValue = true; } break; } return(returnValue); }
public static bool MenuAction(OrderEnum option, bool exit) { var list = new List<Employee>(); switch (option) { case OrderEnum.A: list = service.TakeListAndOrder(x => x.LastName).Result; PrintList(list); break; case OrderEnum.N: list = service.TakeListAndOrder(x => x.FirstName).Result; PrintList(list); break; case OrderEnum.P: list = service.TakeListAndOrder(x => x.Position).Result; PrintList(list); break; case OrderEnum.F: list = service.TakeListAndOrder(x => x.SeparationDate).Result; PrintList(list); break; case OrderEnum.S: exit = true; break; default: break; } return exit; }
public bool Equals(OrderEnum obj) { if ((object)obj == null) { return(false); } return(StringComparer.OrdinalIgnoreCase.Equals(this.Value, obj.Value)); }
public OrderProcessor(OrderEnum order, IRuleCommandFacotry ruleCommandFacotry, bool isContinueOnFail) { RuleCommandFacotry = ruleCommandFacotry ?? throw new NullReferenceException("Rule command facotry should not be null"); Order = order; IsContinueOnFail = isContinueOnFail; Console.WriteLine($"Order processor created for {Order.ToString()}"); }
public static string ToExplain(this OrderEnum that) { switch (that) { case OrderEnum.Asc: return("ASC"); case OrderEnum.Desc: return("DESC"); } return(""); }
private IQueryable <Product> ApplyOrder(IQueryable <Product> queryProducts, ProductFields orderField, OrderEnum order) { switch (orderField) { case ProductFields.productCode: if (order == OrderEnum.Ascending) { queryProducts = queryProducts.OrderBy(x => x.productCode); } else { queryProducts = queryProducts.OrderByDescending(x => x.productCode); } break; case ProductFields.productDescription: if (order == OrderEnum.Ascending) { queryProducts = queryProducts.OrderBy(x => x.productDescription); } else { queryProducts = queryProducts.OrderByDescending(x => x.productDescription); } break; case ProductFields.productGTIN: if (order == OrderEnum.Ascending) { queryProducts = queryProducts.OrderBy(x => x.productGTIN); } else { queryProducts = queryProducts.OrderByDescending(x => x.productGTIN); } break; case ProductFields.productName: if (order == OrderEnum.Ascending) { queryProducts = queryProducts.OrderBy(x => x.productName); } else { queryProducts = queryProducts.OrderByDescending(x => x.productName); } break; default: queryProducts = queryProducts.OrderBy(x => x.productId); break; } return(queryProducts); }
public void MergeSort(OrderEnum listOrder) { switch (listOrder) { case OrderEnum.IDOrder: this.MergeSort(); break; case OrderEnum.TitleOrder: this.MergeSort(Document.CompareTitles); break; case OrderEnum.MatchOrder: this.MergeSort(Document.CompareMatches); break; } }
public void TestWhere5() { var repository = new Repository <DictInfo>(Conn); OrderEnum orderEnum = OrderEnum.optionA; var rst = repository.Where(x => x.OrderNum == orderEnum); Assert.NotEmpty(rst); foreach (var item in rst) { Assert.Equal(OrderEnum.optionA, item.OrderNum); } }
public void TestWhere7() { var repository = new Repository <DictInfo2>(Conn); OrderEnum orderEnum = OrderEnum.optionA; var rst = repository.Where(x => x.OrderNum == orderEnum); Assert.AreNotEqual(0, rst.Count); foreach (var item in rst) { Assert.AreEqual(OrderEnum.optionA, item.OrderNum); } }
public SortHolder CreateSortQuery(string sort, OrderEnum order) { return(new SortHolder( new List <ISort> { new SortStandard(sort) { Order = order } } )); }
/// <summary> /// 生成单号 /// </summary> /// <param name="orderEnum">单号类型</param> /// <param name="CompanyID">企业ID</param> /// <returns></returns> public static string Generator(OrderEnum orderEnum, int CompanyID) { switch (orderEnum) { case OrderEnum.OWR: return(OWRGenerator.CreateNo(CompanyID)); case OrderEnum.OWS: return(OWSGenerator.CreateNo(CompanyID)); case OrderEnum.IC: return(ICGenerator.CreateNo(CompanyID)); case OrderEnum.IS: return(ISGenerator.CreateNo(CompanyID)); case OrderEnum.IR: return(IRGenerator.CreateNo(CompanyID)); case OrderEnum.SOWR: return(SOWRGenerator.CreateNo(CompanyID)); case OrderEnum.SO: return(SOGenerator.CreateNo(CompanyID)); case OrderEnum.PO: return(POGenerator.CreateNo(CompanyID)); case OrderEnum.WO: return(WOGenerator.CreateNo(CompanyID)); case OrderEnum.MO: return(MOGenerator.CreateNo(CompanyID)); case OrderEnum.PMR: return(PMRGenerator.CreateNo(CompanyID)); case OrderEnum.PDR: return(PDRGenerator.CreateNo(CompanyID)); case OrderEnum.PR: return(PRGenerator.CreateNo(CompanyID)); case OrderEnum.MR: return(MRGenerator.CreateNo(CompanyID)); case OrderEnum.PDC: return(PDCGenerator.CreateNo(CompanyID)); default: return(""); } }
public async Task <(List <Recipe>, int)> getRecipes(int startat, int quantity, List <string> fields, RecipeFields orderField, OrderEnum order) { var recipesQuery = _context.Recipes.AsQueryable(); recipesQuery = ApplyMultifilter(recipesQuery, fields); recipesQuery = ApplyOrder(recipesQuery, orderField, order); var recipesId = await recipesQuery .Skip(startat).Take(quantity) .Select(x => x.recipeId) .ToListAsync(); var queryCount = _context.Recipes.AsQueryable(); queryCount = ApplyMultifilter(recipesQuery, fields); queryCount = ApplyOrder(queryCount, orderField, order); var totalCount = queryCount.Count(); List <Recipe> recipes = new List <Recipe> (); foreach (var item in recipesId) { var recipe = await getRecipe(item); if (recipe != null) { if (recipe.recipeTypeId != null) { var recipeType = await _recipeTypeService.getRecipeType(recipe.recipeTypeId.Value); if (recipeType != null) { recipe.typeDescription = recipeType.typeDescription; } } recipe.phases = new List <Phase> (); foreach (var phaseId in recipe.phasesId) { var phase = await _phaseService.getPhase(phaseId); if (phase != null) { recipe.phases.Add(phase); } } recipes.Add(recipe); } } return(recipes, totalCount); }
public int BinarySearch(Document document, OrderEnum listOrder) { int listIndex = 0; switch (listOrder) { case OrderEnum.IDOrder: listIndex = this.BinarySearch(document); break; case OrderEnum.TitleOrder: listIndex = this.BinarySearch(document, OrderEnum.TitleOrder); break; case OrderEnum.MatchOrder: listIndex = this.BinarySearch(document, OrderEnum.MatchOrder); break; } return(listIndex); }
/// <summary> /// Converts a OrderEnum value to a corresponding string value /// </summary> /// <param name="enumValue">The OrderEnum value to convert</param> /// <returns>The representative string value</returns> public static string ToValue(OrderEnum enumValue) { switch (enumValue) { //only valid enum elements can be used //this is necessary to avoid errors case OrderEnum.ENUM_USERFIRSTNAME: case OrderEnum.ENUM_USERLASTNAME: case OrderEnum.ENUM_CLIENTREGISTRATIONDATE: case OrderEnum.ENUM_CLIENTID: return(stringValues[(int)enumValue]); //an invalid enum value was requested default: return(null); } }
private IQueryable <Tag> ApplyOrder(IQueryable <Tag> queryTags, TagFieldEnum orderField, OrderEnum order) { switch (orderField) { case TagFieldEnum.physicalTag: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.physicalTag); } else { queryTags = queryTags.OrderByDescending(x => x.physicalTag); } break; case TagFieldEnum.tagDescription: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.tagDescription); } else { queryTags = queryTags.OrderByDescending(x => x.tagDescription); } break; case TagFieldEnum.tagName: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.tagName); } else { queryTags = queryTags.OrderByDescending(x => x.tagName); } break; default: queryTags = queryTags.OrderBy(x => x.tagId); break; } return(queryTags); }
private IQueryable <Recipe> ApplyOrder(IQueryable <Recipe> query, RecipeFields orderField, OrderEnum order) { switch (orderField) { case RecipeFields.recipeCode: if (order == OrderEnum.Ascending) { query = query.OrderBy(x => x.recipeCode); } else { query = query.OrderByDescending(x => x.recipeCode); } break; case RecipeFields.recipeName: if (order == OrderEnum.Ascending) { query = query.OrderBy(x => x.recipeName); } else { query = query.OrderByDescending(x => x.recipeName); } break; case RecipeFields.recipeTypeId: if (order == OrderEnum.Ascending) { query = query.OrderBy(x => x.recipeTypeId); } else { query = query.OrderByDescending(x => x.recipeTypeId); } break; default: query = query.OrderBy(x => x.recipeId); break; } return(query); }
public virtual void MDXOrderTuple(ref string OrderTuple, ref OrderEnum Order) { OrderTuple = null; if (this.Ordinal == 2) { return; } for (int i = 0; i < this.Hierarchies.Count; i++) { Hierarchy hier = this.Hierarchies[i]; if (hier.OrderTupleMember != null) { if (_order == OrderEnum.NONE) { hier._orderTupleMember = null; } else { OrderTuple = OrderTuple + hier.OrderTupleMember + ","; } } else if (hier.OrderTupleMember == null) { if (_order != OrderEnum.NONE) { _order = OrderEnum.NONE; i = -1; //restart for } OrderTuple = null; } } //remove last comma if (OrderTuple != null && OrderTuple.EndsWith(",")) { OrderTuple = OrderTuple.Remove(OrderTuple.Length - 1, 1); } Order = _order; }
private static VKParams parseParamsForGet( IEnumerable<FieldsEnum> fields, Int64? userId, OrderEnum? order, Int64? listId, Int32? count, Int32? offset, NameCaseEnum? nameCase ) { VKParams param = new VKParams(); if (fields != null) { param.Add("fields", String.Join(",", fields)); } if (userId.HasValue) { param.Add("user_id", userId.Value); } if (order.HasValue) { param.Add("order", order.Value); } if (listId.HasValue) { param.Add("list_id", listId.Value); } if (count.HasValue) { param.Add("count", count.Value); } if (offset.HasValue) { param.Add("offset", offset.Value); } if (nameCase.HasValue) { param.Add("name_case", nameCase.Value); } return param; }
public void Test_Orders_Should_Return_True(OrderEnum orderEnum) { // Prepare var op = new OrderProcessor(orderEnum, new RuleCommandFacotry(), true); // Run var result = op.RunCommands(); // Assert Assert.AreEqual(orderEnum, op.Order); Assert.IsTrue(op.IsContinueOnFail); Assert.AreEqual(0, result); if (orderEnum == OrderEnum.LearningToSki) { Assert.AreEqual(1, op.RuleCommands.Count()); } else { Assert.AreEqual(2, op.RuleCommands.Count()); } }
/// <summary> /// Initializes a new instance of the <see cref="InputCollectionSort" /> class. /// </summary> /// <param name="input">Collection of strings to sort (required).</param> /// <param name="order">Sort order (required) (default to OrderEnum.Ascending).</param> public InputCollectionSort(List <string> input = default(List <string>), OrderEnum order = OrderEnum.Ascending) { // to ensure "input" is required (not null) if (input == null) { throw new InvalidDataException("input is a required property for InputCollectionSort and cannot be null"); } else { this.Input = input; } // to ensure "order" is required (not null) if (order == null) { throw new InvalidDataException("order is a required property for InputCollectionSort and cannot be null"); } else { this.Order = order; } }
/// <summary> /// Initializes a new instance of the <see cref="AccessLists" /> class. /// </summary> /// <param name="cidrs">Classless Inter-Domain Routing IP notation for use on the access lists (required).</param> /// <param name="order">Allow-Deny or Deny-Allow? (required).</param> /// <param name="userAgent">Regexp to match valid user agent strings.</param> public AccessLists(List <string> cidrs = default(List <string>), OrderEnum order = default(OrderEnum), string userAgent = default(string)) { // to ensure "cidrs" is required (not null) if (cidrs == null) { throw new InvalidDataException("cidrs is a required property for AccessLists and cannot be null"); } else { this.Cidrs = cidrs; } // to ensure "order" is required (not null) if (order == null) { throw new InvalidDataException("order is a required property for AccessLists and cannot be null"); } else { this.Order = order; } this.UserAgent = userAgent; }
internal void LoadFromXml(XmlElement xmlEl) { if (this.Ordinal != 2) { this._order = (OrderEnum)System.Enum.Parse(typeof(OrderEnum), xmlEl.GetAttribute("SO"), true); this._emptyTupleOption = (EmptyTupleOptionEnum)System.Enum.Parse(typeof(EmptyTupleOptionEnum), xmlEl.GetAttribute("ETO"), true); } foreach (XmlElement hierEl in xmlEl.ChildNodes) //hierarchies { string uniqueName = hierEl.GetAttribute("UN"); Olap.Hierarchy hier = Schema.Hierarchies[uniqueName]; if (hier == null) { continue; } //move to specified axis hier.Axis = this; hier.LoadFromXml(hierEl); } }
public ScraperInfoDto GetScraperInfo(OrderEnum order) { var result = _scraperInfoRepository.GetScraperInfo(Enum.GetName(typeof(OrderEnum), order)); if (result != null) { return(new ScraperInfoDto { Order = (OrderEnum)Enum.Parse(typeof(OrderEnum), result.Order), LastPage = result.LastPage, LastRun = result.LastRun }); } else { return(new ScraperInfoDto { Order = order, LastPage = 0, LastRun = DateTime.Now }); } }
static void Main(string[] args) { OrderEnum order1 = OrderEnum.done; if (order1 == OrderEnum.done) { Console.WriteLine("La commande est terminé"); } OrderEnum orderChoosen = OrderEnum.undefined; Console.WriteLine("Choisissez le statut"); int choice = Int32.Parse(Console.ReadLine()); switch (choice) { case 0: orderChoosen = OrderEnum.pending; break; case 1: orderChoosen = OrderEnum.done; break; case 2: orderChoosen = OrderEnum.canceled; break; default: break; } Console.WriteLine("Votre commande est maintenant " + orderChoosen); Console.ReadLine(); }
public OrderAgg(string field, OrderEnum order) { _field = field; _order = order; }
public static List <User> GetUsers(string userType, string userName, ActiveStatusEnum active, UserOrderEnum order, OrderEnum orderDirection) { try { List <User> retVal = new List <User>(); using (SqlConnection connection = new SqlConnection(DBFunctions.ConnectionString)) { SqlCommand command = connection.CreateCommand(); command.CommandText = String.Format(@" SELECT {0} FROM [user].[User] JOIN [user].[UserType] ON [User].[UserTypeId] = [UserType].[Id] WHERE (@UserType IS NULL OR [user].[UserType].Name LIKE @UserType) AND (@UserName IS NULL OR [user].[User].Name LIKE @UserName) AND (@Active IS NULL OR [user].[User].Active = @Active) ", AllColumnSelect); command.Parameters.Add("@UserType", SqlDbType.NVarChar); command.Parameters.Add("@UserName", SqlDbType.NVarChar); command.Parameters.Add("@Active", SqlDbType.Bit); command.Parameters["@UserType"].Value = CreateLikeQueryString(userType); command.Parameters["@UserName"].Value = CreateLikeQueryString(userName); switch (active) { case ActiveStatusEnum.Active: command.Parameters["@Active"].Value = true; break; case ActiveStatusEnum.Inactive: command.Parameters["@Active"].Value = false; break; case ActiveStatusEnum.All: command.Parameters["@Active"].Value = DBNull.Value; break; } System.Diagnostics.Debug.WriteLine(command.CommandText); connection.Open(); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { retVal.Add(ReadRow(reader)); } } } return(retVal); } catch (Exception ex) { Logger.WriteLog(ex); throw ErrorResponse.ErrorMessage(HttpStatusCode.BadRequest, ex); } }
/// <summary> /// 设置 排序方式 默认asc /// </summary> /// <param name="order"></param> /// <returns></returns> public FluentGridColumn Order(OrderEnum order) { Column.Order = order; return this; }
private IQueryable <Tool> ApplyOrder(IQueryable <Tool> queryTags, ToolFieldEnum orderField, OrderEnum order) { switch (orderField) { case ToolFieldEnum.Code: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.code); } else { queryTags = queryTags.OrderByDescending(x => x.code); } break; case ToolFieldEnum.Description: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.description); } else { queryTags = queryTags.OrderByDescending(x => x.description); } break; case ToolFieldEnum.Name: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.name); } else { queryTags = queryTags.OrderByDescending(x => x.name); } break; case ToolFieldEnum.SerialNumber: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.serialNumber); } else { queryTags = queryTags.OrderByDescending(x => x.serialNumber); } break; case ToolFieldEnum.Status: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.status); } else { queryTags = queryTags.OrderByDescending(x => x.status); } break; case ToolFieldEnum.TypeName: if (order == OrderEnum.Ascending) { queryTags = queryTags.OrderBy(x => x.typeName); } else { queryTags = queryTags.OrderByDescending(x => x.typeName); } break; default: queryTags = queryTags.OrderBy(x => x.toolId); break; } return(queryTags); }
public async Task <(List <Tool>, int)> getTools(int startat, int quantity, ToolFieldEnum fieldFilter, string fieldValue, ToolFieldEnum orderField, OrderEnum order) { var queryTool = _context.Tools.Where(x => x.toolId > 0).Include(x => x.toolType).AsQueryable(); queryTool = ApplyFilter(queryTool, fieldFilter, fieldValue); queryTool = ApplyOrder(queryTool, orderField, order); var toolId = await queryTool .Skip(startat).Take(quantity) .Select(x => x.toolId) .ToListAsync(); var queryToolCount = _context.Tools.Where(x => x.toolId > 0); queryToolCount = ApplyFilter(queryToolCount, fieldFilter, fieldValue); queryToolCount = ApplyOrder(queryToolCount, orderField, order); var totalCount = await queryToolCount.CountAsync(); List <Tool> tools = new List <Tool> (); foreach (var item in toolId) { var tool = await getTool(item); if (tool != null) { tools.Add(tool); } } return(tools, totalCount); }
public async Task <(List <User>, int)> getUsers(int startat, int quantity, UserFieldEnum fieldFilter, string fieldValue, UserFieldEnum orderField, OrderEnum order) { var queryUser = _context.Users.Where(x => x.enabled == true); queryUser = ApplyFilter(queryUser, fieldFilter, fieldValue); queryUser = ApplyOrder(queryUser, orderField, order); var users = await queryUser.Include(x => x.userGroup) .Skip(startat).Take(quantity).ToListAsync(); var queryUserCount = _context.Users.Where(x => x.enabled == true); queryUserCount = ApplyFilter(queryUserCount, fieldFilter, fieldValue); queryUserCount = ApplyOrder(queryUserCount, orderField, order); var totalCount = await queryUserCount.CountAsync(); return(users, totalCount); }
// Locate and return the index of data public int BinarySearch(Employee employee, OrderEnum listOrder) { // in the list. The list must be ordered int listIndex = 0; // by the value of the listOrder parameter. switch (listOrder) { case OrderEnum.IDOrder: listIndex = this.BinarySearch(employee); break; case OrderEnum.NameOrder: listIndex = this.BinarySearch(employee, Employee.CompareNames); break; case OrderEnum.HireDateOrder: listIndex = this.BinarySearch(employee, Employee.CompareHireDates); break; case OrderEnum.TypeOrder: listIndex = this.BinarySearch(employee, Employee.CompareTypes); break; case OrderEnum.EarningsOrder: listIndex = this.BinarySearch(employee, Employee.CompareEarnings); break; case OrderEnum.FICAOrder: listIndex = this.BinarySearch(employee, Employee.CompareFICAs); break; case OrderEnum.FedTaxOrder: listIndex = this.BinarySearch(employee, Employee.CompareFedTaxes); break; case OrderEnum.StateTaxOrder: listIndex = this.BinarySearch(employee, Employee.CompareStateTaxes); break; case OrderEnum.NetPayOrder: listIndex = this.BinarySearch(employee, Employee.CompareNetPays); break; } return listIndex; }
// The value of the listOrder parameter public void SelectionSort(OrderEnum listOrder) { // determines the sort order. switch (listOrder) { case OrderEnum.IDOrder: this.SelectionSort(); break; case OrderEnum.NameOrder: this.SelectionSort(Employee.CompareNames); break; case OrderEnum.HireDateOrder: this.SelectionSort(Employee.CompareHireDates); break; case OrderEnum.TypeOrder: this.SelectionSort(Employee.CompareTypes); break; case OrderEnum.EarningsOrder: this.SelectionSort(Employee.CompareEarnings); break; case OrderEnum.FICAOrder: this.SelectionSort(Employee.CompareFICAs); break; case OrderEnum.FedTaxOrder: this.SelectionSort(Employee.CompareFedTaxes); break; case OrderEnum.StateTaxOrder: this.SelectionSort(Employee.CompareStateTaxes); break; case OrderEnum.NetPayOrder: this.SelectionSort(Employee.CompareNetPays); break; } }
public OrderBy(string name, OrderEnum order, CharacterCasingEnum casing = CharacterCasingEnum.Unchanged) { this.Name = name; this.Order = order; this.Casing = casing; }
/// <summary> /// Возвращает расширенную информацию о друзьях пользователя /// </summary> /// <param name="fields">Cписок дополнительных полей, которые необходимо вернуть</param> /// <param name="userId"> /// Идентификатор пользователя, для которого необходимо получить список друзей. Если параметр не /// задан, то считается, что он равен идентификатору текущего пользователя /// </param> /// <param name="order">Порядок, в котором нужно вернуть список друзей</param> /// <param name="listId">Идентификатор списка друзей, друзей из которого необходимо получить</param> /// <param name="count">Количество друзей, которое нужно вернуть</param> /// <param name="offset">Смещение, необходимое для выборки определенного подмножества друзей</param> /// <param name="nameCase">Падеж для склонения имени и фамилии пользователя</param> /// <returns>Список друзей</returns> public static VKList<VKFriend> GetExtended( IEnumerable<FieldsEnum> fields, Int64? userId = null, OrderEnum? order = null, Int64? listId = null, Int32? count = null, Int32? offset = null, NameCaseEnum? nameCase = null ) { VKParams param = parseParamsForGet(fields, userId, order, listId, count, offset, nameCase); string response = VKSession.Instance.DoRequest("friends.get", param); JObject obj = JObject.Parse(response); if (obj["response"] == null) return null; var objArr = JsonConvert.DeserializeObject<VKList<VKFriend>>(obj["response"].ToString()); return objArr; }
/// <summary> /// Возвращает расширенную информацию о друзьях пользователя /// </summary> /// <param name="fields">Cписок дополнительных полей, которые необходимо вернуть</param> /// <param name="userId"> /// Идентификатор пользователя, для которого необходимо получить список друзей. Если параметр не /// задан, то считается, что он равен идентификатору текущего пользователя /// </param> /// <param name="order">Порядок, в котором нужно вернуть список друзей</param> /// <param name="listId">Идентификатор списка друзей, друзей из которого необходимо получить</param> /// <param name="count">Количество друзей, которое нужно вернуть</param> /// <param name="offset">Смещение, необходимое для выборки определенного подмножества друзей</param> /// <param name="nameCase">Падеж для склонения имени и фамилии пользователя</param> /// <param name="token">Токен для отмены выполнения запроса</param> /// <returns>Список друзей</returns> public static async Task<VKList<VKFriend>> GetExtendedAsync( IEnumerable<FieldsEnum> fields, Int64? userId = null, OrderEnum? order = null, Int64? listId = null, Int32? count = null, Int32? offset = null, NameCaseEnum? nameCase = null, CancellationToken? token = null ) { VKParams param = parseParamsForGet(fields, userId, order, listId, count, offset, nameCase); string response = await VKSession.Instance.DoRequestAsync("friends.get", param); JObject obj = JObject.Parse(response); if (obj["response"] == null) return null; var objArr = await JsonConvert.DeserializeObjectAsync<VKList<VKFriend>>(obj["response"].ToString()); if (token.HasValue) token.Value.ThrowIfCancellationRequested(); return objArr; }
// Locate and return the listIndex public int BinarySearch(Student student, OrderEnum listOrder) { // position of element in the list. int listIndex = 1; // Assumes the list is ordered in listOrder. switch (listOrder) { case OrderEnum.IDOrder : listIndex = this.BinarySearch(student); break; case OrderEnum.NameOrder : listIndex = this.BinarySearch(student, Student.CompareNames); break; case OrderEnum.BirthDateOrder : listIndex = this.BinarySearch(student, Student.CompareBirthDates); break; case OrderEnum.MajorOrder : listIndex = this.BinarySearch(student, Student.CompareMajors); break; case OrderEnum.HoursOrder : listIndex = this.BinarySearch(student, Student.CompareHours); break; case OrderEnum.GPAOrder : listIndex = this.BinarySearch(student, Student.CompareGPAs); break; } return listIndex; }
public void SelectionSort(OrderEnum listOrder) { switch (listOrder) { case OrderEnum.IDOrder : this.SelectionSort(); break; case OrderEnum.NameOrder : this.SelectionSort(Student.CompareNames); break; case OrderEnum.BirthDateOrder : this.SelectionSort(Student.CompareBirthDates); break; case OrderEnum.MajorOrder : this.SelectionSort(Student.CompareMajors); break; case OrderEnum.HoursOrder : this.SelectionSort(Student.CompareHours); break; case OrderEnum.GPAOrder : this.SelectionSort(Student.CompareGPAs); break; } }