public void TestAddRange()
{
var list = new List<string> { "aaa", "bbb", "ccc" };
var set = new ObservableList<string>(list);
Assert.AreEqual(set.Count, list.Count);
bool propertyChangedInvoked = false;
bool collectionChangedInvoked = false;
set.PropertyChanged += (sender, e) =>
{
Assert.AreEqual(e.PropertyName, nameof(ObservableList<string>.Count));
propertyChangedInvoked = true;
};
set.CollectionChanged += (sender, e) =>
{
Assert.AreEqual(e.Action, NotifyCollectionChangedAction.Add);
Assert.AreEqual(e.NewStartingIndex, 3);
Assert.NotNull(e.NewItems);
Assert.AreEqual(e.NewItems.Count, 2);
Assert.AreEqual(e.NewItems[0], "ddd");
Assert.AreEqual(e.NewItems[1], "eee");
collectionChangedInvoked = true;
};
set.AddRange(new[] { "ddd", "eee" });
Assert.AreEqual(set.Count, 5);
Assert.AreEqual(set[0], "aaa");
Assert.AreEqual(set[1], "bbb");
Assert.AreEqual(set[2], "ccc");
Assert.AreEqual(set[3], "ddd");
Assert.AreEqual(set[4], "eee");
Assert.True(propertyChangedInvoked);
Assert.True(collectionChangedInvoked);
}
public Morpher(ITraceManager traceManager, Language lang)
{
_lang = lang;
_traceManager = traceManager;
_allomorphTries = new Dictionary <Stratum, RootAllomorphTrie>();
var morphemes = new ObservableList <Morpheme>();
foreach (Stratum stratum in _lang.Strata)
{
var allomorphs = new HashSet <RootAllomorph>(stratum.Entries.SelectMany(entry => entry.Allomorphs));
var trie = new RootAllomorphTrie(ann => ann.Type() == HCFeatureSystem.Segment);
foreach (RootAllomorph allomorph in allomorphs)
{
trie.Add(allomorph);
}
_allomorphTries[stratum] = trie;
morphemes.AddRange(stratum.Entries);
morphemes.AddRange(stratum.MorphologicalRules.OfType <AffixProcessRule>());
morphemes.AddRange(stratum.AffixTemplates.SelectMany(t => t.Slots).SelectMany(s => s.Rules).Distinct());
}
_analysisRule = lang.CompileAnalysisRule(this);
_synthesisRule = lang.CompileSynthesisRule(this);
MaxStemCount = 2;
LexEntrySelector = entry => true;
RuleSelector = rule => true;
_morphemes = new ReadOnlyObservableCollection <Morpheme>(morphemes);
}
public ItemsListSample()
{
var obsList = new ObservableList <IComponent>();
var vs = VisibilitySensor((v) =>
{
obsList.Remove(v);
obsList.AddRange(GetSomeItems(20));
v.Reset();
obsList.Add(v);
});
obsList.AddRange(GetSomeItems(10));
obsList.Add(vs);
_content = SectionStack().WidthStretch()
.Title(SampleHeader(nameof(ItemsListSample)))
.Section(
Stack()
.Children(
SampleTitle("Overview"),
TextBlock("List provides a base component for rendering small sets of items. " +
"It is agnostic of the tile component used, and selection " +
"management. These concerns can be layered separately.")
.PaddingBottom(16.px()),
TextBlock("Performance is adequate for smaller lists, for large number of items use VirtualizedList.")
.PaddingBottom(16.px())))
.Section(
Stack()
.Children(
SampleTitle("Usage"),
TextBlock("Basic List")
.Medium()
.PaddingBottom(16.px()),
ItemsList(GetSomeItems(10)).PaddingBottom(16.px()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Basic List with columns")
.Medium()
.PaddingBottom(16.px()),
ItemsList(GetSomeItems(100), 25.percent(), 25.percent(), 25.percent(), 25.percent()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Basic List with VisibilitySensor")
.Medium()
.PaddingBottom(16.px()),
ItemsList(obsList, 25.percent(), 25.percent(), 25.percent(), 25.percent()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Basic List with Empty List Message ")
.Medium()
.PaddingBottom(16.px()),
ItemsList(new IComponent[0], 25.percent(), 25.percent(), 25.percent(), 25.percent())
.WithEmptyMessage(() => BackgroundArea(Card(TextBlock("Empty list").Padding(16.px()))).WidthStretch().HeightStretch().MinHeight(100.px()))
.Height(500.px())));
}
public void AddRange_FiresCollectionChanged()
{
var list = new ObservableList<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int eventFireCount = 0;
list.CollectionChanged += (sender, args) =>
{
eventFireCount++;
Assert.AreEqual(NotifyCollectionChangedAction.Add, args.Action);
switch (eventFireCount)
{
case 1:
Assert.AreEqual(9, args.NewStartingIndex);
Assert.IsTrue(new[] { 10 }.SequenceEqual(args.NewItems.Cast<int>()));
break;
case 2:
Assert.AreEqual(10, args.NewStartingIndex);
Assert.IsTrue(new[] { 11 }.SequenceEqual(args.NewItems.Cast<int>()));
break;
}
};
list.AddRange(new[] { 10, 11 });
}
public void AddRange_FiresCollectionChanged()
{
var list = new ObservableList <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9
};
int eventFireCount = 0;
list.CollectionChanged += (sender, args) =>
{
eventFireCount++;
Assert.AreEqual(NotifyCollectionChangedAction.Add, args.Action);
switch (eventFireCount)
{
case 1:
Assert.AreEqual(9, args.NewStartingIndex);
Assert.IsTrue(new[] { 10 }.SequenceEqual(args.NewItems.Cast <int>()));
break;
case 2:
Assert.AreEqual(10, args.NewStartingIndex);
Assert.IsTrue(new[] { 11 }.SequenceEqual(args.NewItems.Cast <int>()));
break;
}
};
list.AddRange(new[] { 10, 11 });
}
public MainWindow()
{
InitializeComponent();
LogRecords = new ObservableList <LogRecord>();
DataContext = this;
new Thread(() =>
{
LogRecord record = new LogRecord();
record.Message = "Hello, world.";
record.Timestamp = DateTime.Now;
List <LogRecord> logRecordList = new List <LogRecord>();
for (int i = 0; i < 1000000; i++)
{
logRecordList.Add(record);
}
Stopwatch timer = new Stopwatch();
timer.Start();
Dispatcher.Invoke(() =>
{
LogRecords.AddRange(logRecordList);
});
timer.Stop();
Console.WriteLine("The operation took {0} milliseconds.", timer.ElapsedMilliseconds);
}).Start();
}
public void AddRangeNotifiesAsResetInsteadOfIndividualItemsWhenItemCountAboveThresholdTest(int lowerLimit, int upperLimit)
{
// given
var rangeToAdd = Enumerable.Range(lowerLimit, upperLimit - lowerLimit + 1).ToList();
var testScheduler = new TestScheduler();
var testObserverCollectionChanges = testScheduler.CreateObserver<IObservableCollectionChange<int>>();
var testObserverResets = testScheduler.CreateObserver<Unit>();
using (var observableList = new ObservableList<int>())
{
// when
observableList.ThresholdAmountWhenChangesAreNotifiedAsReset = 0;
observableList.CollectionChanges.Subscribe(testObserverCollectionChanges);
observableList.Resets.Subscribe(testObserverResets);
testScheduler.Schedule(TimeSpan.FromTicks(100), () => { observableList.AddRange(rangeToAdd); });
testScheduler.Start();
// then
var shouldBeReset = rangeToAdd.Count >= observableList.ThresholdAmountWhenChangesAreNotifiedAsReset;
testObserverCollectionChanges.Messages.Count.Should().Be(shouldBeReset ? 1 : rangeToAdd.Count);
testObserverCollectionChanges.Messages.Should()
.Match(recordedMessages =>
recordedMessages.All(message => message.Value.Value.ChangeType == (shouldBeReset ? ObservableCollectionChangeType.Reset : ObservableCollectionChangeType.ItemAdded)));
testObserverResets.Messages.Count.Should().Be(shouldBeReset ? 1 : 0);
}
}
public void AddRangeNotifiesAsResetInsteadOfIndividualItemsWhenItemCountAboveThresholdTest(int lowerLimit, int upperLimit)
{
// given
var rangeToAdd = Enumerable.Range(lowerLimit, upperLimit - lowerLimit + 1).ToList();
var testScheduler = new TestScheduler();
var testObserverCollectionChanges = testScheduler.CreateObserver <IObservableCollectionChange <int> >();
var testObserverResets = testScheduler.CreateObserver <Unit>();
using (var observableList = new ObservableList <int>())
{
// when
observableList.ThresholdAmountWhenChangesAreNotifiedAsReset = 0;
observableList.CollectionChanges.Subscribe(testObserverCollectionChanges);
observableList.Resets.Subscribe(testObserverResets);
testScheduler.Schedule(TimeSpan.FromTicks(100), () => { observableList.AddRange(rangeToAdd); });
testScheduler.Start();
// then
var shouldBeReset = rangeToAdd.Count >= observableList.ThresholdAmountWhenChangesAreNotifiedAsReset;
testObserverCollectionChanges.Messages.Count.Should().Be(shouldBeReset ? 1 : rangeToAdd.Count);
testObserverCollectionChanges.Messages.Should()
.Match(recordedMessages =>
recordedMessages.All(message => message.Value.Value.ChangeType == (shouldBeReset ? ObservableCollectionChangeType.Reset : ObservableCollectionChangeType.ItemAdded)));
testObserverResets.Messages.Count.Should().Be(shouldBeReset ? 1 : 0);
}
}
public void UnitTest4(ObservableList <int> list)
{
// ARRANGE
EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;
list.AddRange(new[] { 6, 5, 2 });
Assert.True(list.Contains(6));
Assert.True(list.Contains(5));
Assert.True(list.Contains(2));
list.Undo();
Assert.False(list.Contains(6));
Assert.False(list.Contains(5));
Assert.False(list.Contains(2));
Assert.Equal(
5,
list.Count);
// ACT
list.Redo();
// ASSERT
Assert.True(list.Contains(6));
Assert.True(list.Contains(5));
Assert.True(list.Contains(2));
Assert.Equal(
8,
list.Count);
}
public void SetInstructions(ImmutableList <string> instructions)
{
_instructions.Clear();
_instructions.AddRange(instructions);
_playhead.Value = 0;
Save();
}
public void HandleMessage(Message message)
{
var messageHash = message.Hash;
T value = (T)message.Body.Value;
var predecessors = message.Predecessors;
if (!_predecessors.Contains(messageHash))
{
_candidates.Add(new Candidate <T>(messageHash, value));
}
var newPredecessors = predecessors.Except(_predecessors);
_candidates.RemoveAll(c => newPredecessors.Contains(c.MessageHash));
_predecessors.AddRange(newPredecessors);
}
public void AddRange_ItemCountOverThresHold_FiresCollectionChanged()
{
var list = new ObservableList<int> { 1, 2, 3, 4, 5 };
list.CollectionChanged += (sender, args) => Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
list.AddRange(new[] { 6, 7, 8, 9, 10 });
}
protected void UpdateTemplateList()
{
templates.Clear();
if (SelectedGroup != null)
{
templates.AddRange(SelectedGroup.GetTemplatesRecursively());
}
}
private void OnStudyLoaded(object sender, StudyLoadedEventArgs e)
{
_availableContexts.AddRange(e.Study.Series
.SelectMany(s => s.Sops)
.Where(s => s.SopClassUid == SopClass.KeyObjectSelectionDocumentStorageUid)
.Select(s => new KeyImageInformation(_studyTree, s))
.OrderByDescending(s => s.ContentDateTime)
.ThenBy(s => s.SeriesNumber));
}
private void _listTestButton_Click(object sender, EventArgs e)
{
var list = new ObservableList <string>();
list.ObservationWindow.ItemAdded += (dict, value, key) =>
_outputWriter.WriteLine("Single event: Added {0} at {1} ", value, key);
list.ObservationWindow.ItemRemoved += (dict, value, key) =>
_outputWriter.WriteLine("Single event: Removed {0} at {1} ", value, key);
list.ObservationWindow.Changed += (dict, events) => {
_outputWriter.WriteLine("Global Handler");
foreach (var @event in events)
{
_outputWriter.WriteLine("\t: {0} {1} at {2} ", @event.EventType, @event.Item, @event.Location);
}
};
list.Add("string 1");
list.Add("string 2");
list.RemoveAt(1);
list.Remove("string 1");
list.AddRange(new [] { "bulk 1", "bulk 2" });
list.AddRange(new[] { "bulk 3", "bulk 4" });
list.RemoveRange(2, 2);
list.RemoveAt(1);
list.RemoveAt(0);
list.AddRange(new[] { "bulk 5", "bulk 6" });
list.Clear();
list.Add("padding 1");
list.Add("padding 2");
list.AddRange(new [] { "padding 6", "padding 7" });
list.Insert(2, "single insert 3");
list.InsertRange(3, new [] { "bulk insert 4", "bulk insert 5" });
_outputWriter.WriteLine("Should be 1,2,3,4,5,6,7: {0}", list.ToDelimittedString(", "));
list.RemoveRange(1, 5);
_outputWriter.WriteLine("Should be 1, 7: {0}", list.ToDelimittedString(", "));
list.Clear();
}
public void SelectedMain()
{
var list = AllSecondaryGroups[MainGroup.SelectedItem.Name];
xOffset.Value = (int)((MainGroup.SelectedIndex + 0.5f - MainGroup.Count / 2f) * 100);
SecondaryGroup.Clear();
SecondaryGroup.AddRange(list);
_controller.SelectedTool = null;
}
public Asn1Tree(Asn1Reader asn)
{
if (asn == null)
{
throw new ArgumentNullException("asn");
}
RawData = new ObservableList <Byte>(true);
RawData.AddRange(asn.RawData);
m_initialize(asn);
}
public void Initialize(MetaData metaData)
{
var newModels = metaData.Select(info => new ItemPreviewModel(_store, _relay, info));
_models.AddRange(newModels);
foreach (var model in _models)
{
_modelsByHash[model.FileHash] = model;
}
}
public void AddRange_ItemCountOverThresHold_FiresCollectionChanged()
{
var list = new ObservableList <int> {
1, 2, 3, 4, 5
};
list.CollectionChanged += (sender, args) => Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
list.AddRange(new[] { 6, 7, 8, 9, 10 });
}
private ObservableList <RouterOutput> getAllOutputs()
{
ObservableList <RouterOutput> outputs = new ObservableList <RouterOutput>();
foreach (Router router in routers)
{
outputs.AddRange(router.Outputs);
}
return(outputs);
}
public TimelineSample()
{
var obsList = new ObservableList <IComponent>();
var vs = VisibilitySensor((v) =>
{
obsList.Remove(v);
obsList.AddRange(GetSomeItems(20));
v.Reset();
obsList.Add(v);
});
obsList.AddRange(GetSomeItems(10));
obsList.Add(vs);
_content = SectionStack().WidthStretch()
.Title(SampleHeader(nameof(TimelineSample)))
.Section(
Stack()
.Children(
SampleTitle("Overview"),
TextBlock("Timeline provides a base component for rendering vertical timelines. " +
"It is agnostic of the tile component used, and selection " +
"management. These concerns can be layered separately.")
.PaddingBottom(16.px())))
.Section(
Stack()
.Children(
SampleTitle("Usage"),
TextBlock("Timeline").Medium().PaddingBottom(16.px()),
Timeline().Children(GetSomeItems(10)).PaddingBottom(16.px()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Timeline with Max Width").Medium().PaddingBottom(16.px()),
Timeline().TimelineWidth(600.px()).Children(GetSomeItems(10)).PaddingBottom(16.px()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Timeline Same Side").Medium().PaddingBottom(16.px()),
Timeline().SameSide().Children(GetSomeItems(10)).PaddingBottom(16.px()).Height(500.px()).PaddingBottom(32.px()),
TextBlock("Timeline Same Side with Max Width").Medium().PaddingBottom(16.px()),
Timeline().TimelineWidth(600.px()).SameSide().Children(GetSomeItems(10)).PaddingBottom(16.px()).Height(500.px()).PaddingBottom(32.px())
));
}
public void TemplatePagesRangeAdded()
{
var page = CreateMultiPage();
page.ItemTemplate = new DataTemplate(() =>
{
var p = new ContentPage();
p.Content = new Label();
p.Content.SetBinding(Label.TextProperty, new Binding("."));
return(p);
});
var items = new ObservableList <string> {
"Foo", "Bar"
};
page.ItemsSource = items;
Action <IList <Element>, int, string> assertPage = (ps, index, s) =>
{
Page p = (Page)ps[index];
Assert.That(p, Is.InstanceOf <ContentPage>());
Assert.That(GetIndex((T)p), Is.EqualTo(index));
var cp = (ContentPage)p;
Assert.That(cp.Content, Is.InstanceOf <Label>());
Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
};
int addedCount = 0;
page.PagesChanged += (sender, e) =>
{
if (e.Action != NotifyCollectionChangedAction.Add)
{
return;
}
addedCount++;
Assert.That(e.NewItems.Count, Is.EqualTo(2));
};
items.AddRange(new[] { "Baz", "Bam" });
Assert.That(addedCount, Is.EqualTo(1));
var pages = page.Children.ToArray();
Assert.That(pages.Length, Is.EqualTo(4));
assertPage(pages, 0, "Foo");
assertPage(pages, 1, "Bar");
assertPage(pages, 2, "Baz");
assertPage(pages, 3, "Bam");
}
public void AddRangeWithIEnumerableCollection()
{
var list = new ObservableList <int>();
Assert.AreEqual(0, list.Count);
list.AddRange(new List <int> {
1, 2, 3
}.Where(t => t > 0));
Assert.AreEqual(3, list.Count);
}
public void AddRangeWithObservableList()
{
var list = new ObservableList <int>();
Assert.AreEqual(0, list.Count);
list.AddRange(new ObservableList <int> {
1, 2, 3
});
Assert.AreEqual(3, list.Count);
}
public MainWindowViewModel()
{
WinList = new ObservableList <Type>();
ProgramStart_Click = new RelayCommand(SelectedWindowStart);
Hyperlink_Click = new RelayCommand(LanguageChange);
LanguageChange();
var assems = Assembly.GetExecutingAssembly().DefinedTypes;
var result = from a in assems where a.BaseType.Name == "Window" && a.Name != "MainWindow" orderby a.Name select a;
WinList.AddRange(result);
}
public void HandleAllMessages(IEnumerable <Message> messages)
{
var predecessors = messages
.SelectMany(m => m.Predecessors)
.ToLookup(h => h);
var candidates = messages
.Where(m => !predecessors.Contains(m.Hash))
.Select(m => new Candidate <T>(m.Hash, (T)m.Body.Value));
_candidates.RemoveAll(c => predecessors.Contains(c.MessageHash));
_predecessors.AddRange(predecessors.Select(p => p.Key));
_candidates.AddRange(candidates);
}
public TaxonListViewModel()
{
RegroupListCommand = new Command <TaxonListGroup>(arg => RegroupList(arg));
SelectedTaxonListSource = new ObservableList <Taxon>();
HiddenTaxonList = new ObservableList <Taxon>();
SelectedTaxonList = new ObservableList <TaxonListGroup>();
EnableSearchbar = true;
SelectedTaxonListSource.AddRange(((App)App.Current).Taxa.Where(t => t.TaxonomyStateName == "sp.").ToList());
PlaceholderText = $"Suchen in {SelectedTaxonListSource.Count} Arten";
OnPropertyChanged(nameof(PlaceholderText));
OnPropertyChanged(nameof(EnableSearchbar));
OnPropertyChanged(nameof(SearchText));
}
public void HandleAllMessages(IEnumerable <Message> messages)
{
var cardsDeleted = messages
.Where(m => m.Type == "CardDeleted")
.Select(m => Guid.Parse(m.Body.CardId))
.ToLookup(g => g);
var cardsCreated = messages
.Where(m => m.Type == "CardCreated")
.Select(m => Guid.Parse(m.Body.CardId))
.Where(g => !cardsDeleted.Contains(g))
.Select(g => new Card(g));
_cards.AddRange(cardsCreated);
}
public KeyImageClipboard(StudyTree studyTree)
{
_studyTree = studyTree;
_currentContext = new KeyImageInformation();
_availableContexts = new ObservableList<KeyImageInformation> {_currentContext};
_availableContexts.AddRange(_studyTree.Studies
.SelectMany(s => s.Series)
.SelectMany(s => s.Sops)
.Where(s => s.SopClassUid == SopClass.KeyObjectSelectionDocumentStorageUid)
.Select(s => new KeyImageInformation(studyTree, s))
.OrderByDescending(s => s.ContentDateTime)
.ThenBy(s => s.SeriesNumber));
}
void UpdateViewOptions()
{
viewOptions.Clear();
viewOptions.AddRange("Prediction", "Reference");
if (Graph?.Data?.Characteristics != null)
{
foreach (var characteristic in Graph.Data.Characteristics)
{
viewOptions.Add("Characteristic_" + characteristic);
}
}
viewOptions.Add("Observation");
NotifyPropertyChanged("ViewOptions");
}
public KeyImageClipboard(StudyTree studyTree)
{
_studyTree = studyTree;
_currentContext = new KeyImageInformation();
_availableContexts = new ObservableList <KeyImageInformation> {
_currentContext
};
_availableContexts.AddRange(_studyTree.Studies
.SelectMany(s => s.Series)
.SelectMany(s => s.Sops)
.Where(s => s.SopClassUid == SopClass.KeyObjectSelectionDocumentStorageUid)
.Select(s => new KeyImageInformation(studyTree, s))
.OrderByDescending(s => s.ContentDateTime)
.ThenBy(s => s.SeriesNumber));
}
public StoryboardParametersModel(IEnumerable <ImageFileInfo> imagesInfo)
{
_imagesInfo = imagesInfo;
_sampleIDDefinitionModel = new SampleIDDefinitionModel();
_allSampleIDs = new Computed <IEnumerable <SampleID> >(() =>
ComputeAllSampleIDs(_sampleIDDefinitionModel));
_selectedSampleIDs = new ObservableList <SampleID>(_allSampleIDs.Value);
// when the list of all sample IDs changes, change the _selectedSampleIDs, so that by default all the items
// in the CheckedComboBox get selected in UI. This is a user requirement specification for our case.
_allSampleIDs.Subscribe(s =>
{
_selectedSampleIDs.Clear();
_selectedSampleIDs.AddRange(_allSampleIDs.Value);
});
}
/// <summary>
/// Sets dune locations and calculations for the failure mechanism.
/// </summary>
/// <param name="duneLocations">The dune locations to add to the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="duneLocations"/> is <c>null</c>.</exception>
public void SetDuneLocations(IEnumerable <DuneLocation> duneLocations)
{
if (duneLocations == null)
{
throw new ArgumentNullException(nameof(duneLocations));
}
duneLocationCollection.Clear();
duneLocationCollection.AddRange(duneLocations);
DuneLocationCalculationsForUserDefinedTargetProbabilities.ForEach(dlc =>
{
dlc.DuneLocationCalculations.Clear();
dlc.DuneLocationCalculations.AddRange(duneLocations.Select(dl => new DuneLocationCalculation(dl)));
});
}
/// <summary>
/// Constructor with necessary parameter
/// </summary>
/// <param name="baseProjectPath">The root project path</param>
public MappingMonitor(string baseProjectPath)
{
if (string.IsNullOrWhiteSpace(baseProjectPath))
{
throw new ArgumentException(
string.Format(Languages.Global.Str1ArgumentIsInvalid, nameof(baseProjectPath)),
nameof(baseProjectPath));
}
if (Directory.Exists(baseProjectPath) == false)
{
try {
Directory.CreateDirectory(baseProjectPath);
Directory.Delete(baseProjectPath);
}
catch {
throw new ArgumentException(
string.Format(Languages.Global.Str1ArgumentIsInvalid, nameof(baseProjectPath)),
nameof(baseProjectPath));
}
}
BaseProjectPath = baseProjectPath;
if (BaseProjectPath.EndsWith($"{Path.DirectorySeparatorChar}") == false)
{
BaseProjectPath = BaseProjectPath + Path.DirectorySeparatorChar;
}
GlossaryPath = Path.Combine(BaseProjectPath, GlossaryFolderName);
mFileList = new ObservableList <string>(Directory.GetFiles(BaseProjectPath, "*.*", SearchOption.AllDirectories));
mFileList.AddRange(Directory.GetDirectories(BaseProjectPath, "*", SearchOption.AllDirectories));
// finally, prepare FileSystemWatcher instance
mWatcher = new FileSystemWatcher();
mWatcher.Path = BaseProjectPath;
mWatcher.NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName |
NotifyFilters.LastWrite | NotifyFilters.Size;
mWatcher.Filter = "*.*";
mWatcher.IncludeSubdirectories = true;
mWatcher.Changed += OnFileChanged;
mWatcher.Created += OnFileChanged;
mWatcher.Deleted += OnFileChanged;
mWatcher.Renamed += OnFileRenamed;
mWatcher.EnableRaisingEvents = false;
}
private IEnumerator CollectionTestA1()
{
var listA = new List <object>(collectionTestCount);
var listB = new List <object>(collectionTestCount);
for (int i = 0; i < collectionTestCount; i++)
{
listA.Add(i);
listB.Add(2 * i);
}
var collection = new ObservableList <object>(collectionTestCount);
collection.CollectionChanged += (sender, arg) => { };
var test = RunMemoryTestAsync("CollectionTestA1", () =>
{
// add
for (int i = 0; i < collectionTestCount; i++)
{
collection.Add(listA[i]);
}
// indexer
for (int i = 0; i < collectionTestCount; i++)
{
collection[i] = listB[i];
}
// remove
for (int i = 0; i < collectionTestCount; i++)
{
collection.RemoveAt(0);
}
// range
for (int i = 0; i < collectionTestCount; i++)
{
collection.AddRange(listA);
collection.Clear();
}
});
yield return(StartCoroutine(test));
}
public void AddRangeIncreasesCountTest(int lowerLimit, int upperLimit)
{
// given
var rangeToAdd = Enumerable.Range(lowerLimit, upperLimit - lowerLimit + 1).ToList();
var testScheduler = new TestScheduler();
var testObserver = testScheduler.CreateObserver<int>();
using (var observableList = new ObservableList<int>())
{
// when
observableList.ThresholdAmountWhenChangesAreNotifiedAsReset = rangeToAdd.Count + 1;
observableList.CountChanges.Subscribe(testObserver);
testScheduler.Schedule(TimeSpan.FromTicks(100), () => { observableList.AddRange(rangeToAdd); });
testScheduler.Start();
// then
observableList.Count.Should().Be(rangeToAdd.Count);
}
}
public void AddRangeNotifiesCountAfterResetWhenItemCountAboveThresholdTest(int lowerLimit, int upperLimit)
{
// given
var rangeToAdd = Enumerable.Range(lowerLimit, upperLimit - lowerLimit + 1).ToList();
var testScheduler = new TestScheduler();
var testObserver = testScheduler.CreateObserver<int>();
using (var observableList = new ObservableList<int>())
{
// when
observableList.ThresholdAmountWhenChangesAreNotifiedAsReset = 0;
observableList.CountChanges.Subscribe(testObserver);
testScheduler.Schedule(TimeSpan.FromTicks(100), () => { observableList.AddRange(rangeToAdd); });
testScheduler.Start();
// then
testObserver.Messages.Count.Should().Be(1);
testObserver.Messages.Last().Should().NotBeNull();
testObserver.Messages.Last().Value.Value.Should().Be(observableList.Count);
}
}
/// <summary>
/// The convert.
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="targetType">
/// The target type.
/// </param>
/// <param name="parameter">
/// The parameter.
/// </param>
/// <param name="culture">
/// The culture.
/// </param>
/// <returns>
/// </returns>
/// <exception cref="ArgumentNullException">
/// </exception>
/// <exception cref="NotImplementedException">
/// </exception>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
var bytes = (byte[])value;
if (targetType.IsAssignableFrom(typeof(IEnumerable)))
{
var observable = new ObservableList<SixteenBytes>();
if (bytes != null && bytes.Length > 0)
{
Task.Factory.StartNew(
() =>
{
const int ChunkSize = 16;
var chunk = new List<SixteenBytes>(ChunkSize);
int n;
var len = bytes.Length;
for (n = 0; n < len; n += SixteenBytes.Size)
{
chunk.Add(new SixteenBytes { Value = bytes, Index = n });
if (chunk.Count == chunk.Capacity)
{
observable.AddRange(chunk);
chunk = new List<SixteenBytes>(ChunkSize);
}
}
if (n < len)
{
chunk.Add(new SixteenBytes { Value = bytes, Index = n });
}
if (chunk.Count > 0)
{
observable.AddRange(chunk);
}
});
}
return observable;
}
throw new NotImplementedException();
}
