/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
instance = this; // this sets the static Instance property to this instance.
Plugins = new ObservableCollection<PluginBase>();
Devices = new ObservableCollection<Device>();
Motors = new ObservableCollection<MotorViewModel>();
Plugins.CollectionChanged += Plugins_CollectionChanged;
Controllers = new ObservableCollection<ControllerViewModel>();
Controllers.CollectionChanged += Controllers_CollectionChanged;
Robot = new Robot();
// This lets us know what's going on with the Robot's internal Joint collection.
Robot.Controllers.CollectionChanged += RobotControllers_CollectionChanged;
//InputSignalRegistry = new ViewModel.SignalSinkRegistryViewModel();
InputSignalRegistry = new ObservableDictionary<string, string>();
Messenger.Default.Register<Messages.RemoveController>(this,
(message) =>
{
Controllers.Remove(message.ControllerToRemove);
com = this.Robot.Com;
}
);
}
/// <summary>
/// Get display resource for current project.
/// </summary>
/// <returns>Resource of project as a dictionary.</returns>
public static void InitDisplayResources()
{
var culture = GetCurrentCulture();
if (Resource != null)
{
return;
}
Resource = new ObservableDictionary<string, string>();
try
{
var resourceStringMap = ResourceManager.Current.MainResourceMap.GetSubtree("Resources");
foreach (var key in resourceStringMap.Keys)
{
// get resources base on context language
Resource[key] = resourceStringMap.GetValue(key, culture).ValueAsString;
}
}
catch (Exception exception)
{
LogManager.Instance.LogException(exception.ToString());
}
Resource["DOW_1"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[0];
Resource["DOW_2"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[1];
Resource["DOW_3"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[2];
Resource["DOW_4"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[3];
Resource["DOW_5"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[4];
Resource["DOW_6"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[5];
Resource["DOW_7"] = CultureInfo.CurrentCulture.DateTimeFormat.DayNames[6];
}
public void ShouldBindBetweenIndexedObjects()
{
var binder = new Binder<ObservableDictionary<UniversalStub>>();
var dict= new ObservableDictionary<UniversalStub>();
binder.BindIf(x => x.ContainsKey("first") && x.ContainsKey("second"), x => x["first"].String).To(x => x["second"].String);
using (binder.Attach(dict))
{
var first = new UniversalStub();
var second = new UniversalStub { String = "a" };
dict.Add("second", second);
second.String.ShouldBe("a");
using (second.VerifyChangedOnce("String"))
{
dict.Add("first", first);
}
second.String.ShouldBe(null);
using (second.VerifyChangedOnce("String"))
{
first.String = "b";
}
second.String.ShouldBe("b");
}
}
/// <summary>
/// Constructs a new GeomagicTouch View Model
/// </summary>
public GeomagicTouchViewModel()
{
DeviceNames = new ObservableCollection<string>();
SignalSources = new ObservableDictionary<string, SignalSourceViewModel>();
SignalSources.Add("X", new SignalSourceViewModel("X Position"));
SignalSources.Add("Y", new SignalSourceViewModel("Y Position"));
SignalSources.Add("Z", new SignalSourceViewModel("Z Position"));
SignalSources.Add("Theta1", new SignalSourceViewModel("Gimbal Theta 1"));
SignalSources.Add("Theta2", new SignalSourceViewModel("Gimbal Theta 2"));
SignalSources.Add("Theta3", new SignalSourceViewModel("Gimbal Theta 3"));
SignalSources.Add("Inkwell", new SignalSourceViewModel("Inkwell Switch"));
SignalSources.Add("Button1", new SignalSourceViewModel("Button 1"));
SignalSources.Add("Button2", new SignalSourceViewModel("Button 2"));
SignalSources.Add("Button3", new SignalSourceViewModel("Button 1"));
SignalSources.Add("Button4", new SignalSourceViewModel("Button 2"));
TypeName = "Geomagic Touch";
// Get a list of all GeomagicTouch device names
foreach(string device in GetGeomagicDevices())
{
DeviceNames.Add(device);
}
UpdateTimer = new System.Timers.Timer();
UpdateTimer.Elapsed += UpdateTimer_Elapsed;
UpdateTimer.Interval = 50;
}
private void BlockTypes_OnAdded(object sender, ObservableDictionary<string, JSBlockType>.DictionaryEventArgs e)
{
var material = new Material(BaseBlockMaterial);
material.color = GetColor(e.Value);
blockMaterials.Add(e.Key, material);
e.Value.ColorChanged += BlockType_ColorChanged;
}
public PluginDataItem(Views.Plugins.PluginBase plugin)
{
TypeName = plugin.GetType().ToString();
Outputs = plugin.Outputs;
Inputs = plugin.Inputs;
InstanceName = plugin.InstanceName;
}
protected override void OnStartup( StartupEventArgs e )
{
base.OnStartup( e );
mMainWindow = new MainWindow();
var windowDescriptions = new ObservableDictionary<string, D3D11HwndDescription>
{
{
"TileManager2D",
new D3D11HwndDescription
{
Handle = mMainWindow.TileManager2DViewerContext.D3D11RenderingPaneHost.Handle,
Width = mMainWindow.TileManager2DViewerContext.D3D11RenderingPaneHost.Width,
Height = mMainWindow.TileManager2DViewerContext.D3D11RenderingPaneHost.Height
}
},
};
mEngine = new Engine( windowDescriptions );
mUpdateTimer = new DispatcherTimer( DispatcherPriority.Input ) { Interval = TimeSpan.FromMilliseconds( Settings.Default.TargetFrameTimeMilliseconds ) };
mUpdateTimer.Tick += TickHandler;
mUpdateTimer.Start();
var engineDataContext = new EngineDataContext( mEngine, new TileManagerDataContext( mEngine.TileManager ) );
mMainWindow.DataContext = engineDataContext;
mMainWindow.Closing += OnMainWindowClosing;
mMainWindow.Show();
}
/// <summary>Initializes a new instance of the <see cref="SwaggerService"/> class.</summary>
public SwaggerService()
{
Swagger = "2.0";
Schemes = new List<SwaggerSchema>();
Responses = new Dictionary<string, SwaggerResponse>();
SecurityDefinitions = new Dictionary<string, SwaggerSecurityScheme>();
Info = new SwaggerInfo
{
Version = string.Empty,
Title = string.Empty
};
Definitions = new ObservableDictionary<string, JsonSchema4>();
Definitions.CollectionChanged += (sender, args) =>
{
foreach (var pair in Definitions.Where(p => string.IsNullOrEmpty(p.Value.TypeName)))
pair.Value.TypeName = pair.Key;
};
Paths = new ObservableDictionary<string, SwaggerOperations>();
Paths.CollectionChanged += (sender, args) =>
{
foreach (var path in Paths.Values)
path.Parent = this;
};
}
public void AddItem()
{
_handle = new EventWaitHandle(false, EventResetMode.ManualReset);
var test = new ObservableDictionary<int, string>();
test.ItemAdded += Dictionary_ItemEvent;
test.Add(0, "myValue");
Assert.IsTrue(_handle.WaitOne(10));
}
/// <summary>
/// Class Constructor
/// </summary>
/// <param name="searchPath">The path to search for definitions</param>
public CustomNodeLoader(string searchPath)
{
SearchPath = new ObservableCollection<string>();
SearchPath.Add(searchPath);
NodeNames = new ObservableDictionary<string, Guid>();
NodeCategories = new ObservableDictionary<Guid, string>();
}
public PlayerShip()
{
MaxHull = Hull = 30;
Scrap = 0;
Items = new ObservableDictionary<string, int>();
Items.CollectionChanged += (sender, e) =>
DoShipModified(new ShipModifiedEventArgs("Items", e));
}
public void ObservableDictionaryExtensions_All_ReturnsTrueIfObservableDictionaryIsEmpty()
{
var dictionary = new ObservableDictionary<Int32, String>();
var result = dictionary.All(x => x.Key % 2 == 0);
TheResultingValue(result).ShouldBe(true);
}
public Project()
{
LastAssignedUniqueID = 0;
_lastPageNumber = 0;
PageDictionary = new ObservableDictionary<long, ASGPage>();
ProjectName = "Untitled Project";
DefaultCanvasSettings = new CanvasSettings();
}
/// <summary>
/// Initializes a new s_instance of the <see cref="IOSpec"/> class.
/// </summary>
internal IOSpec()
{
m_input = new ObservableDictionary<string, IOItem>();
m_output = new ObservableDictionary<string, IOItem>();
((INotifyCollectionChanged)m_input).CollectionChanged += new NotifyCollectionChangedEventHandler(IOSpec_CollectionChanged);
((INotifyCollectionChanged)m_output).CollectionChanged += new NotifyCollectionChangedEventHandler(IOSpec_CollectionChanged);
}
public void ObservableDictionaryExtensions_Any_ReturnsFalseIfObservableDictionaryDoesNotContainItems()
{
var dictionary = new ObservableDictionary<Int32, String>();
var result = dictionary.Any();
TheResultingValue(result).ShouldBe(false);
}
public void ToDictionary_Get()
{
var source = new ObservableDictionary<int, string>();
var get2 = Nothing<string>();
source.ToLiveLinq()[2].Subscribe(val => get2 = val);
get2.Should().Be(Nothing<string>());
source.Add(2, "Hi there");
get2.Should().Be(Something("Hi there"));
}
public DisplayAllView()
{
this.InitializeComponent();
EntryRepository = new EntryRepository();
NavigationHelper = new NavigationHelper(this);
DefaultViewModel = new ObservableDictionary();
NavigationHelper.LoadState += NavigationHelper_LoadState;
NavigationHelper.SaveState += NavigationHelper_SaveState;
}
public Run()
: base() {
name = ItemName;
description = ItemDescription;
color = Color.Black;
algorithm = null;
parameters = new ObservableDictionary<string, IItem>();
results = new ObservableDictionary<string, IItem>();
}
public Variety(string name)
{
_name = name;
_words = new WordCollection(this);
_varietyPairs = new VarietyVarietyPairCollection(this);
_affixes = new BulkObservableList<Affix>();
_regions = new BulkObservableList<GeographicRegion>();
_syllablePositionSegmentFreqDists = new ObservableDictionary<FeatureSymbol, FrequencyDistribution<Segment>>();
}
public void ShouldBeEmptyOnConstructionWithNoInitialItems()
{
// given
// when
using (var observableDictionary = new ObservableDictionary<int, string>())
{
// then
observableDictionary.IsEmpty.Should().BeTrue();
}
}
public Tuple()
{
LeftHandSide = new VulcanCollection<Definition>();
RightHandSide = new VulcanCollection<Use>();
DefinedIdentifiers = new ObservableHashSet<Identifier>();
UsedIdentifiers = new ObservableHashSet<Identifier>();
ExternalDefinitions = new ObservableDictionary<Identifier, ObservableHashSet<Definition>>();
LastIdentifierDefinition = new ObservableDictionary<Identifier, Definition>();
}
public MainPage()
{
DefaultViewModel = new ObservableDictionary<String, Object>();
listaAbas = new ObservableCollection<AbaDado>();
this.InitializeComponent();
DefaultViewModel["NavigationItemList"] = listaAbas;
}
// Use this for initialization
void Awake()
{
ScriptEngine = new ScriptEngine();
ScriptEngine.SetGlobalValue("console", new JSConsole(ScriptEngine));
BlockTypes = new ObservableDictionary<string, JSBlockType>();
BlockTypes.OnAdded += HandleBlockTypesOnAdded;
Map = new JSMap(ScriptEngine);
}
public void ObservableDictionaryExtensions_Any_ReturnsTrueIfObservableDictionaryContainsItems()
{
var dictionary = new ObservableDictionary<Int32, String>()
{
{ 1, "A" },
};
var result = dictionary.Any();
TheResultingValue(result).ShouldBe(true);
}
/// <summary>
/// <para>Loads all <see cref="TaskPlugin"/>s that are enabled in <paramref name="plugins"/> and not yet loaded and
/// unloads all <see cref="TaskPlugin"/>s that are disabled in <paramref name="plugins"/> and but still loaded</para>
/// <para>This method is used by <see cref="TaskOptions"/> to notify us about changes</para>
/// <param name="plugins">The list of plugins and whether they shall be enabled</param>
/// </summary>
public void Refresh(ObservableDictionary<string, bool> plugins)
{
foreach (KeyValuePair<string, bool> plugin in plugins)
{
Type type = this.TaskPluginsLoaded.Find(new Predicate<Type>(item => { return item.Name == plugin.Key; }));
if (plugin.Value && type == null) // task is enabled and not loaded
this.loadTask(plugin.Key);
if (!plugin.Value && type != null)
this.unloadTask(type);
}
}
public AddNewView()
{
this.InitializeComponent();
DefaultViewModel = new ObservableDictionary();
Categories = DataHandler.Instance.GetUniqueCategories();
ComboCategories.ItemsSource = Categories;
NavigationHelper = new NavigationHelper(this);
NavigationHelper.LoadState += NavigationHelper_LoadState;
NavigationHelper.SaveState += NavigationHelper_SaveState;
App = (App)Application.Current;
}
/// <summary>
/// <para>Fetches the settings and convert them to a <see cref="ObservableDictionary<string, bool>"/></para>
/// </summary>
/// <returns></returns>
public static ObservableDictionary<string, bool> GetPluginsSetting()
{
ObservableDictionary<string, bool> setting;
if (String.IsNullOrEmpty(Properties.Settings.Default.PluginsEnabled))
setting = new ObservableDictionary<string, bool>();
else
{
XmlSerializer xmlSer = new XmlSerializer(typeof(ObservableDictionary<string, bool>));
setting = (ObservableDictionary<string, bool>)xmlSer.Deserialize(new StringReader(Properties.Settings.Default.PluginsEnabled));
}
return setting;
}
public SwaggerServiceExtended()
{
Tags = new List<SwaggerTagInfo>();
SecurityDefinitions = new Dictionary<string, SwaggerSecuritySchemeExtended>();
Paths = new ObservableDictionary<string, SwaggerOperationsExtended>();
Paths.CollectionChanged += (sender, args) =>
{
foreach (var path in Paths.Values)
path.Parent = this;
};
}
public void ObservableDictionaryExtensions_AnyWithPredicate_ReturnsFalseIfObservableDictionaryDoesNotContainMatchingItems()
{
var dictionary = new ObservableDictionary<Int32, String>()
{
{ 1, "A" },
{ 3, "C" },
};
var result = dictionary.Any(x => x.Key % 2 == 0);
TheResultingValue(result).ShouldBe(false);
}
public ObservableDictionary <string, string> GetCookies()
{
ObservableDictionary <string, string> CookiesDictionary = new ObservableDictionary <string, string>();
#if UNITY_WEBGL
// unfortunately, besthttp does not support cookies in webgl yet
FillCookieUsingBrowser(CookiesDictionary);
#else
FillCookiesWithBestHTTP(CookiesDictionary);
#endif
return(CookiesDictionary);
}
public void ObservableDictionary_RaisesCollectionItemAdded()
{
var dict = new ObservableDictionary <String, Int32>();
var added = false;
dict.CollectionItemAdded += (dictionary, key, value) =>
{
added = (key == "Testing" && value == 1234);
};
dict["Testing"] = 1234;
TheResultingValue(added).ShouldBe(true);
}
public void ObservableDictionaryExtensions_All_ReturnsTrueIfAllItemsMatchPredicate()
{
var dictionary = new ObservableDictionary <Int32, String>()
{
{ 2, "A" },
{ 4, "B" },
{ 6, "C" },
};
var result = dictionary.All(x => x.Key % 2 == 0);
TheResultingValue(result).ShouldBe(true);
}
public void WrapOrdinaryDictionaryIsObservable()
{
var dict = new Dictionary <String, Object>();
var obs = new ObservableDictionary(dict);
var count = 0;
obs.Changed += (s, ev) => count++;
obs.Add("test", "string");
Assert.AreEqual(1, count);
Assert.AreEqual(1, dict.Count);
Assert.AreEqual("string", dict["test"]);
}
public void VerifyNonGenericIDictionaryGetEnumerator()
{
ObservableDictionary <string, string> genericDictionary = new ObservableDictionary <string, string>();
IDictionary testDictionary = genericDictionary;
testDictionary.Add("stringKey1", "TestString");
foreach (KeyValuePair <string, string> item in testDictionary)
{
Assert.AreEqual("stringKey1", item.Key);
Assert.AreEqual("TestString", item.Value);
}
}
public void ObservableDictionaryExtensions_AnyWithPredicate_ReturnsTrueIfObservableDictionaryContainsMatchingItems()
{
var dictionary = new ObservableDictionary <Int32, String>()
{
{ 1, "A" },
{ 2, "B" },
{ 3, "C" },
};
var result = dictionary.Any(x => x.Key % 2 == 0);
TheResultingValue(result).ShouldBe(true);
}
public ClassManagementViewModel(Person connectedPerson, ICommand refreshDataCommand, IMessageBoxService messageBoxService)
: base(messageBoxService)
{
HasRequiredPermissions = connectedPerson.isSecretary || connectedPerson.isPrincipal;
_refreshDataCommand = refreshDataCommand;
if (HasRequiredPermissions)
{
_schoolData = new SchoolEntities();
AvailableTeachers = new ObservableDictionary <int, string>();
AvailableRooms = new ObservableDictionary <int, string>();
}
}
public void ObservableDictionaryExtensions_CountWithPredicate_ReturnsCorrectSize()
{
var dictionary = new ObservableDictionary <Int32, String>()
{
{ 1, "A" },
{ 2, "B" },
{ 3, "C" },
};
var result = dictionary.Count(x => x.Key % 2 == 0);
TheResultingValue(result).ShouldBe(1);
}
public MainViewModel(IPAddress ip)
{
KillProcessCommand = new ProcessCommand(KillProcess);
ProcessInfos = new ObservableDictionary <uint, ProcessInfo>();
_taskManager = new RemoteWmiTaskManager(ip);
new Thread(ScanProc)
{
IsBackground = true
}.Start();
}
/// <summary>
/// <para>Create a new instance of <see cref="TaskOptions"/></para>
/// </summary>
/// <param name="Main"></param>
public TaskOptions(Main Main)
{
InitializeComponent();
this.Main = Main;
// get plugins from Settings
plugins = GetPluginsAll(Main);
// show them in the DataGridView
pluginBinding = new BindingSource();
pluginBinding.DataSource = plugins;
this.dgvPlugins.DataSource = pluginBinding;
}
private ObservableDictionary <string, string> ParseParams(XPathNavigator navigator)
{
ObservableDictionary <string, string> parametersGroup = new ObservableDictionary <string, string>();
XPathNodeIterator paramIt = navigator.Select("param[@name and @value]");
while (paramIt.MoveNext())
{
string name = paramIt.Current.GetAttribute("name", "");
string value = paramIt.Current.GetAttribute("value", "");
parametersGroup.Add(name, value);
}
return(parametersGroup);
}
public void ChangeValueInObservableDictionaryIsTriggered()
{
var obs = new ObservableDictionary();
var keys = new List <String>();
obs["test"] = false;
obs.Changed += (s, ev) => keys.Add(ev.Key);
obs["test"] = true;
Assert.AreEqual(1, keys.Count);
Assert.AreEqual(1, obs.Count);
Assert.AreEqual(true, obs["test"]);
}
public void KeyIndexerValueSetShouldThrowDisposedExceptionAfterDisposal()
{
// given
var observableDictionary = new ObservableDictionary <int, string>();
observableDictionary.Dispose();
// when
Action action = () => { observableDictionary[1] = "One"; };
// then
action.Should().Throw <ObjectDisposedException>();
}
public void GetEnumeratorTest()
{
var dic = new ObservableDictionary <int, string>();
dic.Add(1, "1");
using (var enumerator = dic.GetEnumerator()) {
enumerator.Reset();
enumerator.MoveNext().Should().BeTrue();
enumerator.Current.Key.Should().Be(1);
enumerator.Current.Value.Should().Be("1");
enumerator.MoveNext().Should().BeFalse();
}
}
public void TryGetShouldThrowDisposedExceptionAfterDisposal()
{
// given
var observableDictionary = new ObservableDictionary <string, string>();
observableDictionary.Dispose();
// when
string value;
Action action = () => observableDictionary.TryGetValue("One", out value);
// then
action.Should().Throw <ObjectDisposedException>();
}
public static XElement DictionaryToXml(ObservableDictionary <string, string> inputDictionary)
{
var ret = new XElement(DICTIONARY);
foreach (var pair in inputDictionary)
{
XElement inner = new XElement(KEYVALUEPAIR);
inner.Add(new XAttribute(KEY, pair.Key));
inner.Add(new XAttribute(VALUE, pair.Value));
ret.Add(inner);
}
return(ret);
}
public void AddOfCollectionOfKeyValuePairsAddsNonExistingItem()
{
// given
using (var observableDictionary = new ObservableDictionary <int, string>())
{
// when
((ICollection <KeyValuePair <int, string> >)observableDictionary).Add(new KeyValuePair <int, string>(1, "One"));
// then
observableDictionary.Count.Should().Be(1);
observableDictionary.Should().Contain(1, "One");
}
}
public void ObservableDictionaryExtensions_Last_ReturnsLastItemInObservableDictionary()
{
var dictionary = new ObservableDictionary <Int32, String>()
{
{ 1, "A" },
{ 2, "B" },
{ 3, "C" },
};
var result = dictionary.Last();
TheResultingValue(result).ShouldBe(new KeyValuePair <Int32, String>(3, "C"));
}
public void ReturnsDefaultFromInvalidKey()
{
var observableDictionary = new ObservableDictionary <int, int>
{
{
1, 1
}
};
var success = observableDictionary.TryGetValue(2, out int value);
Assert.IsTrue(!success && value == 0);
}
public void ReturnsCustomComparer()
{
var customComparer = StringComparer.OrdinalIgnoreCase;
var observableDictionary = new ObservableDictionary <string, int>(customComparer)
{
{
"1", 1
}
};
Assert.AreEqual(customComparer, observableDictionary.Comparer);
}
public void ReturnsValueFromValidKey()
{
var observableDictionary = new ObservableDictionary <int, int>
{
{
1, 1
}
};
var success = observableDictionary.TryGetValue(1, out int value);
Assert.IsTrue(success && value == 1);
}
public void ReturnsDefaultComparer()
{
var defaultComparer = EqualityComparer <int> .Default;
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 1
}
};
Assert.AreEqual(defaultComparer, observableDictionary.Comparer);
}
public void ReturnsNullForInvalidTypedObject()
{
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 1
}
};
var result = observableDictionary[(object)"1"];
Assert.IsNull(result);
}
public void ContainsKeyFalse()
{
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 1
}
};
var success = observableDictionary.ContainsKey(2);
Assert.IsFalse(success);
}
public void ContainsObjectInvalidTypeFalse()
{
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 2
}
};
var result = observableDictionary.Contains((object)"1");
Assert.IsFalse(result);
}
public void ContainsObjectTrue()
{
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 2
}
};
var result = observableDictionary.Contains((object)1);
Assert.IsTrue(result);
}
public void ContainsKvpSuccess()
{
var observableDictionary = new ObservableDictionary <int, int>()
{
{
1, 2
}
};
var result = observableDictionary.Contains(new KeyValuePair <int, int>(1, 2));
Assert.IsTrue(result);
}
private async void GradesTrendGrid_Tapped(object sender, TappedRoutedEventArgs e)
{
this.changePanel(1);
ObservableDictionary observableDictionary = this.DefaultViewModel;
List <Term> list = await Term.GetTermsAsync();
object obj = (object)list;
observableDictionary["GradesTrend"] = obj;
observableDictionary = (ObservableDictionary)null;
list = (List <Term>)null;
obj = (object)null;
this.showStatisticalInfo();
}
public void SyncRootPropertyAccessOfCollectionShouldThrow()
{
// given
using (var observableDictionary = new ObservableDictionary <int, string>())
{
// when
Action action = () => { var syncRoot = ((ICollection)observableDictionary).SyncRoot; };
// then
action
.Should().Throw <NotSupportedException>()
.WithMessage("The SyncRoot property may not be used for the synchronization of concurrent collections.");
}
}
public void ContainsKeyOfReadOnlyDictionaryOfKeyValuePairsThrowsOnNullKey()
{
// given
using (var observableDictionary = new ObservableDictionary <string, string>())
{
// when
Action retrieval = () => ((IReadOnlyDictionary <string, string>)observableDictionary).ContainsKey((string)null);
// then
retrieval
.Should().Throw <ArgumentNullException>()
.WithMessage("Value cannot be null.\r\nParameter name: key");
}
}
public MainForumsPage()
{
DefaultViewModel = new ObservableDictionary();
InitializeComponent();
NavigationHelper = new NavigationHelper(this);
NavigationHelper.LoadState += navigationHelper_LoadState;
}
