public void TestKeyComparer_OrderBy_NullKeyComparer_Throws() { Func <int, int> keySelector = i => i; Comparer <int> keyComparer = null; KeyComparer <int> .OrderBy <int>(keySelector, keyComparer); }
public void RetrieveUserGroups(UserModel user) { if (user == null) { throw new ArgumentNullException("user"); } if (userMapper.AreGroupsLoaded(user)) { return; } user.Groups.EnableSync(); Task.Factory.StartNew(() => { user.Groups.Clear(); var groups = repository.GetUserGroups(user.Name); var groupModels = groups.Select(g => groupMapper.GetModel(g, includeDummy: false)); var modelComparer = KeyComparer <GroupModel> .OrderBy(m => m.Name); foreach (GroupModel model in groupModels) { int index = user.Groups.ToSublist().UpperBound(model, modelComparer); user.Groups.Insert(index, model); } }).ContinueWith( t => onErrorOccurred(t.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext() ); }
public void TestKeyComparer_OrderBy_WithComparer_NullKeySelector_Throws() { Func <int, int> keySelector = null; Comparer <int> keyComparer = Comparer <int> .Default; KeyComparer <int> .OrderBy <int>(keySelector, keyComparer); }
public void RetrieveUserProperties(UserModel user) { if (user == null) { throw new ArgumentNullException("user"); } user.Properties.EnableSync(); Task.Factory.StartNew(() => { user.Properties.Clear(); var properties = repository.GetUserProperties(user.Name); var models = properties.Select(p => propertyMapper.GetModel(p)); var modelComparer = KeyComparer <PropertyModel> .OrderBy(p => p.Name); foreach (PropertyModel model in models) { int index = user.Properties.ToSublist().UpperBound(model, modelComparer); user.Properties.Insert(index, model); } }).ContinueWith( t => onErrorOccurred(t.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext() ); }
public void RetrieveGroupMembers(GroupModel group) { if (group == null) { throw new ArgumentNullException("group"); } if (groupMapper.AreUsersLoaded(group)) { return; } group.Users.EnableSync(); Task.Factory.StartNew(() => { group.Users.Clear(); var users = repository.GetGroupMembers(group.Name); var userModels = users.Select(u => userMapper.GetModel(u, includeDummy: false)); var modelComparer = KeyComparer <UserModel> .OrderBy(m => m.FullName); foreach (UserModel model in userModels) { int index = group.Users.ToSublist().UpperBound(model, modelComparer); group.Users.Insert(index, model); } }).ContinueWith( t => onErrorOccurred(t.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext() ); }
public void Search(string searchTerm) { if (repository == null) { throw new InvalidOperationException("You must share the connection with the model before searching."); } if (Group == null) { throw new InvalidOperationException("You must set the group before searching."); } if (String.IsNullOrWhiteSpace(searchTerm)) { return; } if (searchTokenSource != null) { searchTokenSource.Cancel(); } searchTokenSource = new CancellationTokenSource(); searchTask = searchTask.ContinueWith( t => { IsSearching = true; }, searchTokenSource.Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext() ).ContinueWith(t => { var searchResults = repository.GetUsers(searchTerm, includeGroups: true); return(searchResults); }, searchTokenSource.Token).ContinueWith(t => { CancellationToken token = searchTokenSource.Token; SearchResults.Clear(); Group group = repository.GetGroup(Group.Name); var searchResults = t.Result; var models = searchResults.Select(m => userMapper.GetMemberModel(group.DistinguishedName, m)); var modelComparer = KeyComparer <GroupMemberModel> .OrderBy(m => m.FullName).ThenBy(m => m.Name); foreach (var model in models) { token.ThrowIfCancellationRequested(); int index = SearchResults.ToSublist().UpperBound(model, modelComparer); SearchResults.Insert(index, model); } }, searchTokenSource.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default); searchTask.ContinueWith( t => onErrorOccurred(t.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext() ); searchTask.ContinueWith( t => { IsSearching = false; }, searchTokenSource.Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext() ); }
public void TestKeyComparer_Explicit_NonGeneric() { IComparer comparer = KeyComparer <int> .OrderBy(i => i).Untyped(); int result = comparer.Compare(1, 2); Assert.IsTrue(result < 0, "Failed to compare values explicitly."); }
public void TestKeyComparer_SortStringsByLength() { Random random = new Random(); string[] names = { "Bob", "George", "Mary", "Jessica", "David" }; IComparer <string> comparer = KeyComparer <string> .OrderBy(item => item.Length); Array.Sort(names, comparer); string[] expected = { "Bob", "Mary", "David", "George", "Jessica" }; CollectionAssert.AreEqual(expected, names, "The names were not sorted by length."); }
public void RetrieveUsers(string searchTerm) { if (repository == null) { throw new InvalidOperationException("You must connect to AD before querying the users."); } AreGroupsDisplayed = false; AreUsersDisplayed = true; if (tokenSource != null) { tokenSource.Cancel(); } tokenSource = new CancellationTokenSource(); userTask = userTask.ContinueWith( t => { IsSearching = true; }, tokenSource.Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext() ).ContinueWith(t => { CancellationToken token = tokenSource.Token; Users.Clear(); var users = repository.GetUsers(searchTerm); var models = users.Select(u => userMapper.GetModel(u, includeDummy: true)); var modelComparer = KeyComparer <UserModel> .OrderBy(u => u.FullName); foreach (var model in models) { token.ThrowIfCancellationRequested(); int index = Users.ToSublist().UpperBound(model, modelComparer); Users.Insert(index, model); } }, tokenSource.Token); userTask.ContinueWith( t => onErrorOccurred(t.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext() ); userTask.ContinueWith( t => { IsSearching = false; }, tokenSource.Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext() ); }
public void TestKeyComparer_OrderBy_WithKeyComparison() { // build a week, starting on a Sunday DateTime firstDate = new DateTime(2013, 1, 6); DateTime[] week = new DateTime[] { new DateTime(2013, 1, 6), new DateTime(2013, 1, 7), new DateTime(2013, 1, 8), new DateTime(2013, 1, 9), new DateTime(2013, 1, 10), new DateTime(2013, 1, 11), new DateTime(2013, 1, 12), }; // force Mondays to come first! IComparer <DayOfWeek> dayComparer = NullComparer <DayOfWeek> .Default.ThenBy(day => (DayOfWeek)((int)(day + 6) % 7)); Array.Sort(week, KeyComparer <DateTime> .OrderBy(d => d.DayOfWeek, dayComparer.Compare)); Assert.AreEqual(firstDate, week[week.Length - 1], "Sunday did not get moved to the end of the week."); }