Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

419 lines
14 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Runtime;
using System.ServiceModel.Channels;
public class MessageQueryTable<TItem> : IDictionary<MessageQuery, TItem>
{
Dictionary<Type, MessageQueryCollection> collectionsByType;
Dictionary<MessageQuery, TItem> dictionary;
public MessageQueryTable()
{
this.dictionary = new Dictionary<MessageQuery, TItem>();
this.collectionsByType = new Dictionary<Type, MessageQueryCollection>();
}
public int Count
{
get { return this.dictionary.Count; }
}
public bool IsReadOnly
{
get { return false; }
}
public ICollection<MessageQuery> Keys
{
get { return this.dictionary.Keys; }
}
public ICollection<TItem> Values
{
get { return this.dictionary.Values; }
}
public TItem this[MessageQuery key]
{
get
{
return this.dictionary[key];
}
set
{
this.Add(key, value);
}
}
[SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "collectionsByType", Justification = "No need to support type equivalence here.")]
public void Add(MessageQuery key, TItem value)
{
if (key == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("key");
}
Type queryType = key.GetType();
MessageQueryCollection collection;
if (!this.collectionsByType.TryGetValue(queryType, out collection))
{
collection = key.CreateMessageQueryCollection();
if (collection == null)
{
collection = new SequentialMessageQueryCollection();
}
this.collectionsByType.Add(queryType, collection);
}
collection.Add(key);
this.dictionary.Add(key, value);
}
public void Add(KeyValuePair<MessageQuery, TItem> item)
{
this.Add(item.Key, item.Value);
}
public void Clear()
{
this.collectionsByType.Clear();
this.dictionary.Clear();
}
public bool Contains(KeyValuePair<MessageQuery, TItem> item)
{
return ((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).Contains(item);
}
public bool ContainsKey(MessageQuery key)
{
return this.dictionary.ContainsKey(key);
}
public void CopyTo(KeyValuePair<MessageQuery, TItem>[] array, int arrayIndex)
{
((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).CopyTo(array, arrayIndex);
}
public IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(Message message)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
return new MessageEnumerable<TResult>(this, message);
}
public IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(MessageBuffer buffer)
{
if (buffer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
}
return new MessageBufferEnumerable<TResult>(this, buffer);
}
public IEnumerator<KeyValuePair<MessageQuery, TItem>> GetEnumerator()
{
return ((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
[SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "collectionsByType", Justification = "No need to support type equivalence here.")]
public bool Remove(MessageQuery key)
{
if (this.dictionary.Remove(key))
{
MessageQueryCollection collection;
Type queryType = key.GetType();
collection = this.collectionsByType[queryType];
collection.Remove(key);
if (collection.Count == 0)
{
this.collectionsByType.Remove(queryType);
}
return true;
}
else
{
return false;
}
}
public bool Remove(KeyValuePair<MessageQuery, TItem> item)
{
return this.Remove(item.Key);
}
public bool TryGetValue(MessageQuery key, out TItem value)
{
return this.dictionary.TryGetValue(key, out value);
}
class SequentialMessageQueryCollection : MessageQueryCollection
{
public override IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(Message message)
{
return new MessageSequentialResultEnumerable<TResult>(this, message);
}
public override IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(MessageBuffer buffer)
{
return new MessageBufferSequentialResultEnumerable<TResult>(this, buffer);
}
abstract class SequentialResultEnumerable<TSource, TResult> : IEnumerable<KeyValuePair<MessageQuery, TResult>>
{
SequentialMessageQueryCollection collection;
TSource source;
public SequentialResultEnumerable(SequentialMessageQueryCollection collection, TSource source)
{
this.collection = collection;
this.source = source;
}
SequentialMessageQueryCollection Collection
{
get
{
return this.collection;
}
}
protected TSource Source
{
get
{
return this.source;
}
}
public IEnumerator<KeyValuePair<MessageQuery, TResult>> GetEnumerator()
{
return new SequentialResultEnumerator(this);
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
protected abstract TResult Evaluate(MessageQuery query);
class SequentialResultEnumerator : IEnumerator<KeyValuePair<MessageQuery, TResult>>
{
SequentialResultEnumerable<TSource, TResult> enumerable;
IEnumerator<MessageQuery> queries;
public SequentialResultEnumerator(SequentialResultEnumerable<TSource, TResult> enumerable)
{
this.enumerable = enumerable;
this.queries = enumerable.Collection.GetEnumerator();
}
public KeyValuePair<MessageQuery, TResult> Current
{
get
{
MessageQuery query = queries.Current;
TResult result = enumerable.Evaluate(query);
return new KeyValuePair<MessageQuery, TResult>(query, result);
}
}
object IEnumerator.Current
{
get
{
return this.Current;
}
}
public void Dispose()
{
}
public bool MoveNext()
{
return this.queries.MoveNext();
}
public void Reset()
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
}
}
class MessageSequentialResultEnumerable<TResult> : SequentialResultEnumerable<Message, TResult>
{
public MessageSequentialResultEnumerable(
SequentialMessageQueryCollection collection, Message message)
: base(collection, message)
{
}
protected override TResult Evaluate(MessageQuery query)
{
return query.Evaluate<TResult>(this.Source);
}
}
class MessageBufferSequentialResultEnumerable<TResult> : SequentialResultEnumerable<MessageBuffer, TResult>
{
public MessageBufferSequentialResultEnumerable(
SequentialMessageQueryCollection collection, MessageBuffer buffer)
: base(collection, buffer)
{
}
protected override TResult Evaluate(MessageQuery query)
{
return query.Evaluate<TResult>(this.Source);
}
}
}
abstract class Enumerable<TSource, TResult> : IEnumerable<KeyValuePair<MessageQuery, TResult>>
{
TSource source;
MessageQueryTable<TItem> table;
public Enumerable(MessageQueryTable<TItem> table, TSource source)
{
this.table = table;
this.source = source;
}
protected TSource Source
{
get
{
return this.source;
}
}
public IEnumerator<KeyValuePair<MessageQuery, TResult>> GetEnumerator()
{
return new Enumerator(this);
}
protected abstract IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(MessageQueryCollection collection);
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
class Enumerator : IEnumerator<KeyValuePair<MessageQuery, TResult>>
{
Enumerable<TSource, TResult> enumerable;
IEnumerator<KeyValuePair<MessageQuery, TResult>> innerEnumerator;
IEnumerator<MessageQueryCollection> outerEnumerator;
public Enumerator(Enumerable<TSource, TResult> enumerable)
{
this.outerEnumerator = enumerable.table.collectionsByType.Values.GetEnumerator();
this.enumerable = enumerable;
}
public KeyValuePair<MessageQuery, TResult> Current
{
get { return this.innerEnumerator.Current; }
}
object IEnumerator.Current
{
get
{
return this.Current;
}
}
public void Dispose()
{
}
public bool MoveNext()
{
if (innerEnumerator == null || !this.innerEnumerator.MoveNext())
{
if (!this.outerEnumerator.MoveNext())
{
return false;
}
else
{
MessageQueryCollection collection = this.outerEnumerator.Current;
this.innerEnumerator = this.enumerable.GetInnerEnumerator(collection);
return this.innerEnumerator.MoveNext();
}
}
else
{
return true;
}
}
public void Reset()
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
}
}
class MessageBufferEnumerable<TResult> : Enumerable<MessageBuffer, TResult>
{
public MessageBufferEnumerable(MessageQueryTable<TItem> table, MessageBuffer buffer)
: base(table, buffer)
{
}
protected override IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(
MessageQueryCollection collection)
{
return collection.Evaluate<TResult>(this.Source).GetEnumerator();
}
}
class MessageEnumerable<TResult> : Enumerable<Message, TResult>
{
public MessageEnumerable(MessageQueryTable<TItem> table, Message message)
: base(table, message)
{
}
protected override IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(
MessageQueryCollection collection)
{
return collection.Evaluate<TResult>(this.Source).GetEnumerator();
}
}
}
}