Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
116 changed files
with
4,363 additions
and
0 deletions.
There are no files selected for viewing
412 changes: 412 additions & 0 deletions
412
ShareContractExample/ContosoCookbook/Common/NavigationHelper.cs
Large diffs are not rendered by default.
Oops, something went wrong.
149 changes: 149 additions & 0 deletions
149
ShareContractExample/ContosoCookbook/Common/ObservableDictionary.cs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,149 @@ | ||
using System; | ||
using System.Collections.Generic; | ||
using System.Linq; | ||
using Windows.Foundation.Collections; | ||
|
||
namespace ContosoCookbook.Common | ||
{ | ||
/// <summary> | ||
/// Implementation of IObservableMap that supports reentrancy for use as a default view | ||
/// model. | ||
/// </summary> | ||
public class ObservableDictionary : IObservableMap<string, object> | ||
{ | ||
private class ObservableDictionaryChangedEventArgs : IMapChangedEventArgs<string> | ||
{ | ||
public ObservableDictionaryChangedEventArgs(CollectionChange change, string key) | ||
{ | ||
this.CollectionChange = change; | ||
this.Key = key; | ||
} | ||
|
||
public CollectionChange CollectionChange { get; private set; } | ||
public string Key { get; private set; } | ||
} | ||
|
||
private Dictionary<string, object> _dictionary = new Dictionary<string, object>(); | ||
public event MapChangedEventHandler<string, object> MapChanged; | ||
|
||
private void InvokeMapChanged(CollectionChange change, string key) | ||
{ | ||
var eventHandler = MapChanged; | ||
if (eventHandler != null) | ||
{ | ||
eventHandler(this, new ObservableDictionaryChangedEventArgs(change, key)); | ||
} | ||
} | ||
|
||
public void Add(string key, object value) | ||
{ | ||
this._dictionary.Add(key, value); | ||
this.InvokeMapChanged(CollectionChange.ItemInserted, key); | ||
} | ||
|
||
public void Add(KeyValuePair<string, object> item) | ||
{ | ||
this.Add(item.Key, item.Value); | ||
} | ||
|
||
public bool Remove(string key) | ||
{ | ||
if (this._dictionary.Remove(key)) | ||
{ | ||
this.InvokeMapChanged(CollectionChange.ItemRemoved, key); | ||
return true; | ||
} | ||
return false; | ||
} | ||
|
||
public bool Remove(KeyValuePair<string, object> item) | ||
{ | ||
object currentValue; | ||
if (this._dictionary.TryGetValue(item.Key, out currentValue) && | ||
Object.Equals(item.Value, currentValue) && this._dictionary.Remove(item.Key)) | ||
{ | ||
this.InvokeMapChanged(CollectionChange.ItemRemoved, item.Key); | ||
return true; | ||
} | ||
return false; | ||
} | ||
|
||
public object this[string key] | ||
{ | ||
get | ||
{ | ||
return this._dictionary[key]; | ||
} | ||
set | ||
{ | ||
this._dictionary[key] = value; | ||
this.InvokeMapChanged(CollectionChange.ItemChanged, key); | ||
} | ||
} | ||
|
||
public void Clear() | ||
{ | ||
var priorKeys = this._dictionary.Keys.ToArray(); | ||
this._dictionary.Clear(); | ||
foreach (var key in priorKeys) | ||
{ | ||
this.InvokeMapChanged(CollectionChange.ItemRemoved, key); | ||
} | ||
} | ||
|
||
public ICollection<string> Keys | ||
{ | ||
get { return this._dictionary.Keys; } | ||
} | ||
|
||
public bool ContainsKey(string key) | ||
{ | ||
return this._dictionary.ContainsKey(key); | ||
} | ||
|
||
public bool TryGetValue(string key, out object value) | ||
{ | ||
return this._dictionary.TryGetValue(key, out value); | ||
} | ||
|
||
public ICollection<object> Values | ||
{ | ||
get { return this._dictionary.Values; } | ||
} | ||
|
||
public bool Contains(KeyValuePair<string, object> item) | ||
{ | ||
return this._dictionary.Contains(item); | ||
} | ||
|
||
public int Count | ||
{ | ||
get { return this._dictionary.Count; } | ||
} | ||
|
||
public bool IsReadOnly | ||
{ | ||
get { return false; } | ||
} | ||
|
||
public IEnumerator<KeyValuePair<string, object>> GetEnumerator() | ||
{ | ||
return this._dictionary.GetEnumerator(); | ||
} | ||
|
||
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() | ||
{ | ||
return this._dictionary.GetEnumerator(); | ||
} | ||
|
||
public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex) | ||
{ | ||
int arraySize = array.Length; | ||
foreach (var pair in this._dictionary) | ||
{ | ||
if (arrayIndex >= arraySize) break; | ||
array[arrayIndex++] = pair; | ||
} | ||
} | ||
} | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,7 @@ | ||
The Common directory contains classes that simplify application development. | ||
|
||
Classes in the Common directory form part of your project and may be further enhanced to meet your | ||
needs. Care should be taken when altering existing methods and properties as incompatible changes | ||
will require corresponding changes to code included in a variety of Visual Studio templates. For | ||
example, additional pages added to your project are written assuming that the original methods and | ||
properties in Common classes are still present and that the names of the types have not changed. |
86 changes: 86 additions & 0 deletions
86
ShareContractExample/ContosoCookbook/Common/RelayCommand.cs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,86 @@ | ||
using System; | ||
using System.Collections.Generic; | ||
using System.Linq; | ||
using System.Text; | ||
using System.Threading.Tasks; | ||
using System.Windows.Input; | ||
|
||
namespace ContosoCookbook.Common | ||
{ | ||
/// <summary> | ||
/// A command whose sole purpose is to relay its functionality | ||
/// to other objects by invoking delegates. | ||
/// The default return value for the CanExecute method is 'true'. | ||
/// <see cref="RaiseCanExecuteChanged"/> needs to be called whenever | ||
/// <see cref="CanExecute"/> is expected to return a different value. | ||
/// </summary> | ||
public class RelayCommand : ICommand | ||
{ | ||
private readonly Action _execute; | ||
private readonly Func<bool> _canExecute; | ||
|
||
/// <summary> | ||
/// Raised when RaiseCanExecuteChanged is called. | ||
/// </summary> | ||
public event EventHandler CanExecuteChanged; | ||
|
||
/// <summary> | ||
/// Creates a new command that can always execute. | ||
/// </summary> | ||
/// <param name="execute">The execution logic.</param> | ||
public RelayCommand(Action execute) | ||
: this(execute, null) | ||
{ | ||
} | ||
|
||
/// <summary> | ||
/// Creates a new command. | ||
/// </summary> | ||
/// <param name="execute">The execution logic.</param> | ||
/// <param name="canExecute">The execution status logic.</param> | ||
public RelayCommand(Action execute, Func<bool> canExecute) | ||
{ | ||
if (execute == null) | ||
throw new ArgumentNullException("execute"); | ||
_execute = execute; | ||
_canExecute = canExecute; | ||
} | ||
|
||
/// <summary> | ||
/// Determines whether this <see cref="RelayCommand"/> can execute in its current state. | ||
/// </summary> | ||
/// <param name="parameter"> | ||
/// Data used by the command. If the command does not require data to be passed, this object can be set to null. | ||
/// </param> | ||
/// <returns>true if this command can be executed; otherwise, false.</returns> | ||
public bool CanExecute(object parameter) | ||
{ | ||
return _canExecute == null ? true : _canExecute(); | ||
} | ||
|
||
/// <summary> | ||
/// Executes the <see cref="RelayCommand"/> on the current command target. | ||
/// </summary> | ||
/// <param name="parameter"> | ||
/// Data used by the command. If the command does not require data to be passed, this object can be set to null. | ||
/// </param> | ||
public void Execute(object parameter) | ||
{ | ||
_execute(); | ||
} | ||
|
||
/// <summary> | ||
/// Method used to raise the <see cref="CanExecuteChanged"/> event | ||
/// to indicate that the return value of the <see cref="CanExecute"/> | ||
/// method has changed. | ||
/// </summary> | ||
public void RaiseCanExecuteChanged() | ||
{ | ||
var handler = CanExecuteChanged; | ||
if (handler != null) | ||
{ | ||
handler(this, EventArgs.Empty); | ||
} | ||
} | ||
} | ||
} |
Oops, something went wrong.