/// <summary>
/// Adds an item to this collection.
/// </summary>
/// <param name="value">
/// The item to be added.
/// </param>
/// <returns>
/// The index of the added item.
/// </returns>
int System.Collections.IList.Add(object value)
{
ArgumentHelper.AssertNotNull(value, "value");
ExceptionHelper.ThrowIf(!(value is TItem), "WrongType", value.GetType().FullName, typeof(TItem).FullName);
Add((TItem)value);
return(Count - 1);
}
/// <summary>
/// Copies all items in this collection to the specified array.
/// </summary>
/// <param name="array">
/// The array to copy to.
/// </param>
/// <param name="arrayIndex">
/// The starting index for the copy operation.
/// </param>
void System.Collections.ICollection.CopyTo(Array array, int index)
{
ArgumentHelper.AssertNotNull(array, "array");
ExceptionHelper.ThrowIf(index < 0, "CopyTo.ArrayIndexNegative");
for (int i = 0; i < this.Count; ++i)
{
array.SetValue(this[i], i + index);
}
}
/// <summary>
/// Constructs an instance of <c>DispatchingCollection</c>.
/// </summary>
/// <param name="underlyingCollection">
/// The collection being wrapped by this dispatching collection.
/// </param>
/// <param name="dispatcher">
/// The <see cref="Dispatcher"/> to which <see cref="CollectionChanged"/> notifications will be marshalled.
/// </param>
public DispatchingCollection(TCollection underlyingCollection, Dispatcher dispatcher)
{
ArgumentHelper.AssertNotNull((object)underlyingCollection, "underlyingCollection");
ArgumentHelper.AssertNotNull(dispatcher, "dispatcher");
_underlyingCollection = underlyingCollection;
_dispatcher = dispatcher;
_underlyingCollection.CollectionChanged += (sender, e) =>
{
OnCollectionChanged(e);
};
}
/// <summary>
/// Gets or sets an item in this filtered collection.
/// </summary>
/// <param name="index">
/// The index of the item.
/// </param>
/// <returns>
/// The item at the specified index.
/// </returns>
object System.Collections.IList.this[int index]
{
get
{
return(this[index]);
}
set
{
ArgumentHelper.AssertNotNull(value, "value");
ExceptionHelper.ThrowIf(!(value is TItem), "WrongType", value.GetType().FullName, typeof(TItem).FullName);
this[index] = (TItem)value;
}
}
public static void Raise <T>(EventHandler <T> handler, object sender, CreateEventArguments <T> createEventArguments)
where T : EventArgs
{
ArgumentHelper.AssertNotNull(createEventArguments, "createEventArguments");
if (handler != null)
{
#if DEBUG
RaiseWithDiagnostics(handler, sender, createEventArguments());
#else
handler(sender, createEventArguments());
#endif
}
}
/// <summary>
/// Removes the specified item from this filtered collection.
/// </summary>
/// <param name="value">
/// The item to remove.
/// </param>
/// <returns>
/// <see langword="true"/> if the item was removed, otherwise <see langword="false"/>.
/// </returns>
void System.Collections.IList.Remove(object value)
{
ArgumentHelper.AssertNotNull(value, "value");
ExceptionHelper.ThrowIf(!(value is TItem), "WrongType", value.GetType().FullName, typeof(TItem).FullName);
Remove((TItem)value);
}
public static void Throw(string exceptionKey, object[] constructorArgs, Exception innerException, params object[] messageArgs)
{
ArgumentHelper.AssertNotNull(exceptionKey, "exceptionKey");
//first we need to find the type from which we were invoked - this is used as a grouping mechanism in the XML config file
Type invokingType = null;
int skipFrames = 1;
while (true)
{
StackFrame stackFrame = new StackFrame(skipFrames);
Debug.Assert(stackFrame.GetMethod() != null);
if (stackFrame.GetMethod().DeclaringType != typeof(ExceptionHelper))
{
invokingType = stackFrame.GetMethod().DeclaringType;
break;
}
++skipFrames;
}
XmlDocument exceptionInfo = GetExceptionInfo(invokingType.Assembly);
string xpath = string.Concat("/exceptionHelper/exceptionGroup[@type=\"", invokingType.FullName, "\"]/exception[@key=\"", exceptionKey, "\"]");
XmlNode exceptionNode = exceptionInfo.SelectSingleNode(xpath);
if (exceptionNode == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The exception details for key '{0}' could not be found (they should be under '{1}')", exceptionKey, xpath));
}
XmlAttribute typeAttribute = exceptionNode.Attributes[_typeAttributeName];
if (typeAttribute == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The '{0}' attribute could not be found for exception with key '{1}'", _typeAttributeName, exceptionKey));
}
Type type = Type.GetType(typeAttribute.Value);
if (type == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Type '{0}' could not be loaded for exception with key '{1}'", typeAttribute.Value, exceptionKey));
}
if (!typeof(Exception).IsAssignableFrom(type))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Type '{0}' for exception with key '{1}' does not inherit from '{2}'", type.FullName, exceptionKey, typeof(Exception).FullName));
}
string message = exceptionNode.InnerText.Trim();
if ((messageArgs != null) && (messageArgs.Length > 0))
{
message = string.Format(CultureInfo.InvariantCulture, message, messageArgs);
}
List <object> constructorArgsList = new List <object>();
//message is always first
constructorArgsList.Add(message);
//next, any additional constructor args
if (constructorArgs != null)
{
constructorArgsList.AddRange(constructorArgs);
}
//finally, the inner exception, if any
if (innerException != null)
{
constructorArgsList.Add(innerException);
}
object[] constructorArgsArr = constructorArgsList.ToArray();
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
object state;
ConstructorInfo constructor = null;
try
{
constructor = (ConstructorInfo)Type.DefaultBinder.BindToMethod(bindingFlags, type.GetConstructors(bindingFlags), ref constructorArgsArr, null, null, null, out state);
}
catch (MissingMethodException)
{
//swallow and deal with below
}
if (constructor == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "An appropriate constructor could not be found for exception type '{0}, for exception with key '{1}'", type.FullName, exceptionKey));
}
//create the exception instance
Exception e = (Exception)constructor.Invoke(constructorArgsArr);
//finally, throw the exception
throw e;
}
