Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DataEntity / System / Data / Metadata / Edm / MemberCollection.cs / 1 / MemberCollection.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common;
using System.Reflection;
using System.Text;
using System.Diagnostics;
namespace System.Data.Metadata.Edm
{
///
/// Class representing a collection of member objects
///
internal sealed class MemberCollection : MetadataCollection
{
// This way this collection works is that it has storage for members on the current type and access to
// members in the base types. As of that requirement, MemberCollection has a reference back to the declaring
// type that owns this collection. Whenever MemberCollection is asked to do a look by name, it looks at the
// current collection, if it doesn't find it, then it ask for it from the declaring type's base type's
// MemberCollection. Because of this order, members in derived types hide members in the base type if they
// have the same name. For look up by index, base type members have lower index then current type's members.
// Add/Update/Remove operations on this collection is only allowed for members owned by this MemberCollection
// and not allowed for members owned by MemberCollections in the base types. For example, if the caller tries
// to remove a member by ordinal which is within the base type's member ordinal range, it throws an exception.
// Hence, base type members are in a sense "readonly" to this MemberCollection. When enumerating all the
// members, the enumeration starts from members in the root type in the inheritance chain. With this special
// enumeration requirement, we have a specialized enumerator class for this MemberCollection. See the
// Enumerator class for details on how it works.
#region Constructors
///
/// Default constructor for constructing an empty collection
///
/// The type that has this member collection
/// Thrown if the declaring type is null
public MemberCollection(StructuralType declaringType)
: this(declaringType, null)
{
}
///
/// The constructor for constructing the collection with the given items
///
/// The type that has this member collection
/// The items to populate the collection
/// Thrown if the declaring type is null
public MemberCollection(StructuralType declaringType, IEnumerable items)
: base(items)
{
Debug.Assert(declaringType != null, "This member collection must belong to a declaring type");
_declaringType = declaringType;
}
#endregion
#region Fields
private StructuralType _declaringType;
#endregion
#region Properties
///
/// Returns the collection as a readonly collection
///
public override System.Collections.ObjectModel.ReadOnlyCollection AsReadOnly
{
get
{
return new System.Collections.ObjectModel.ReadOnlyCollection(this);
}
}
///
/// Gets the count on the number of items in the collection
///
public override int Count
{
get
{
return GetBaseTypeMemberCount() + base.Count;
}
}
///
/// Gets an item from the collection with the given index
///
/// The index to search for
/// An item from the collection
/// Thrown if the index is out of the range for the Collection
/// Always thrown on setter
public override EdmMember this[int index]
{
get
{
int relativeIndex = GetRelativeIndex(index);
if (relativeIndex < 0)
{
// This means baseTypeMemberCount must be non-zero, so we can safely cast the base type to StructuralType
return ((StructuralType)_declaringType.BaseType).Members[index];
}
return base[relativeIndex];
}
set
{
throw EntityUtil.OperationOnReadOnlyCollection();
}
}
///
/// Gets an item from the collection with the given identity
///
/// The identity of the item to search for
/// An item from the collection
/// Thrown if identity argument passed in is null
/// Thrown if the Collection does not have an item with the given identity
/// Always thrown on setter
public override EdmMember this[string identity]
{
get
{
EdmMember item = null;
if (!TryGetValue(identity, false, out item))
{
throw EntityUtil.MemberInvalidIdentity(identity, "identity");
}
return item;
}
set
{
throw EntityUtil.OperationOnReadOnlyCollection();
}
}
///
/// Adds an item to the collection
///
/// The item to add to the list
/// Thrown if member argument is null
/// Thrown if the member passed in or the collection itself instance is in ReadOnly state
/// Thrown if the member that is being added already belongs to another MemberCollection
/// Thrown if the MemberCollection already contains a member with the same identity
public override void Add(EdmMember member)
{
// Make sure the member is valid for the add operation.
ValidateMemberForAdd(member, "member");
base.Add(member);
// Fix up the declaring type
member.ChangeDeclaringTypeWithoutCollectionFixup(_declaringType);
}
///
/// Determines if this collection contains an item of the given identity
///
/// The identity of the item to check for
/// True if the collection contains the item with the given identity
public override bool ContainsIdentity(string identity)
{
if (base.ContainsIdentity(identity))
{
return true;
}
// The item is not in this collection, check the base type member collection
EdmType baseType = _declaringType.BaseType;
if (baseType != null && ((StructuralType)baseType).Members.Contains(identity))
{
return true;
}
return false;
}
///
/// Find the index of an item
///
/// The item whose index is to be looked for
/// The index of the found item, -1 if not found
public override int IndexOf(EdmMember item)
{
// Try to get it from this collection, if found, then the relative index needs to be added with the number
// of members in the base type to get the absolute index
int relativeIndex = base.IndexOf(item);
if (relativeIndex != -1)
{
return relativeIndex + GetBaseTypeMemberCount();
}
// Try to find it in the base type
StructuralType baseType = _declaringType.BaseType as StructuralType;
if (baseType != null)
{
return baseType.Members.IndexOf(item);
}
return -1;
}
///
/// Copies the items in this collection to an array
///
/// The array to copy to
/// The index in the array at which to start the copy
/// Thrown if array argument is null
/// Thrown if the arrayIndex is less than zero
/// Thrown if the array argument passed in with respect to the arrayIndex passed in not big enough to hold the MemberCollection being copied
public override void CopyTo(EdmMember[] array, int arrayIndex)
{
// Check on the array index
if (arrayIndex < 0)
{
throw EntityUtil.ArgumentOutOfRange("arrayIndex");
}
// Check if the array together with the array index has enough room to copy
int baseTypeMemberCount = GetBaseTypeMemberCount();
if (base.Count + baseTypeMemberCount > array.Length - arrayIndex)
{
throw EntityUtil.Argument("arrayIndex");
}
// If the base type has any members, copy those first
if (baseTypeMemberCount > 0)
{
((StructuralType)_declaringType.BaseType).Members.CopyTo(array, arrayIndex);
}
base.CopyTo(array, arrayIndex + baseTypeMemberCount);
}
///
/// Gets an item from the collection with the given identity
///
/// The identity of the item to search for
/// Whether case is ignore in the search
/// An item from the collection, null if the item is not found
/// True an item is retrieved
/// if identity argument is null
public override bool TryGetValue(string identity, bool ignoreCase, out EdmMember item)
{
// See if it's in this collection
if (!base.TryGetValue(identity, ignoreCase, out item))
{
// Now go to the parent type to find it
EdmType baseType = _declaringType.BaseType;
if (baseType != null)
{
((StructuralType)baseType).Members.TryGetValue(identity, ignoreCase, out item);
}
}
return item != null;
}
///
/// Get the declared only members of a particular type
///
internal ReadOnlyMetadataCollection GetDeclaredOnlyMembers() where T : EdmMember
{
MetadataCollection newCollection = new MetadataCollection();
for (int i = 0; i < base.Count; i++)
{
T member = base[i] as T;
if (member != null)
{
newCollection.Add(member);
}
}
return newCollection.AsReadOnlyMetadataCollection();
}
///
/// Get the number of members the base type has. If the base type is not a structural type or has no
/// members, it returns 0
///
/// The number of members in the base type
private int GetBaseTypeMemberCount()
{
// The count of members is what in this collection plus base type's member collection
StructuralType baseType = _declaringType.BaseType as StructuralType;
if (baseType != null)
{
return baseType.Members.Count;
}
return 0;
}
///
/// Gets the index relative to this collection for the given index. For an index to really refers to something in
/// the base type, the return value is negative relative to this collection. For an index refers to something in this
/// collection, the return value is positive. In both cases, it's simply (index) - (base type member count)
///
/// The relative index
private int GetRelativeIndex(int index)
{
int baseTypeMemberCount = GetBaseTypeMemberCount();
int thisTypeMemberCount = base.Count;
// Check if the index is in range
if (index < 0 || index >= baseTypeMemberCount + thisTypeMemberCount)
{
throw EntityUtil.ArgumentOutOfRange("index");
}
return index - baseTypeMemberCount;
}
///
/// Checks if the given member already has a declaring type, if so, throw an exception
///
/// The member to check for
/// The name of the argument from the caller
private static void ThrowIfItHasDeclaringType(EdmMember member, string argumentName)
{
EntityUtil.GenericCheckArgumentNull(member, argumentName);
if (member.DeclaringType != null)
{
throw EntityUtil.MemberAlreadyBelongsToType(argumentName);
}
}
private void ValidateMemberForAdd(EdmMember member, string argumentName)
{
// Check to make sure the given member is not associated with another type
ThrowIfItHasDeclaringType(member, argumentName);
// Validate the item with the declaring type.
_declaringType.ValidateMemberForAdd(member);
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common;
using System.Reflection;
using System.Text;
using System.Diagnostics;
namespace System.Data.Metadata.Edm
{
///
/// Class representing a collection of member objects
///
internal sealed class MemberCollection : MetadataCollection
{
// This way this collection works is that it has storage for members on the current type and access to
// members in the base types. As of that requirement, MemberCollection has a reference back to the declaring
// type that owns this collection. Whenever MemberCollection is asked to do a look by name, it looks at the
// current collection, if it doesn't find it, then it ask for it from the declaring type's base type's
// MemberCollection. Because of this order, members in derived types hide members in the base type if they
// have the same name. For look up by index, base type members have lower index then current type's members.
// Add/Update/Remove operations on this collection is only allowed for members owned by this MemberCollection
// and not allowed for members owned by MemberCollections in the base types. For example, if the caller tries
// to remove a member by ordinal which is within the base type's member ordinal range, it throws an exception.
// Hence, base type members are in a sense "readonly" to this MemberCollection. When enumerating all the
// members, the enumeration starts from members in the root type in the inheritance chain. With this special
// enumeration requirement, we have a specialized enumerator class for this MemberCollection. See the
// Enumerator class for details on how it works.
#region Constructors
///
/// Default constructor for constructing an empty collection
///
/// The type that has this member collection
/// Thrown if the declaring type is null
public MemberCollection(StructuralType declaringType)
: this(declaringType, null)
{
}
///
/// The constructor for constructing the collection with the given items
///
/// The type that has this member collection
/// The items to populate the collection
/// Thrown if the declaring type is null
public MemberCollection(StructuralType declaringType, IEnumerable items)
: base(items)
{
Debug.Assert(declaringType != null, "This member collection must belong to a declaring type");
_declaringType = declaringType;
}
#endregion
#region Fields
private StructuralType _declaringType;
#endregion
#region Properties
///
/// Returns the collection as a readonly collection
///
public override System.Collections.ObjectModel.ReadOnlyCollection AsReadOnly
{
get
{
return new System.Collections.ObjectModel.ReadOnlyCollection(this);
}
}
///
/// Gets the count on the number of items in the collection
///
public override int Count
{
get
{
return GetBaseTypeMemberCount() + base.Count;
}
}
///
/// Gets an item from the collection with the given index
///
/// The index to search for
/// An item from the collection
/// Thrown if the index is out of the range for the Collection
/// Always thrown on setter
public override EdmMember this[int index]
{
get
{
int relativeIndex = GetRelativeIndex(index);
if (relativeIndex < 0)
{
// This means baseTypeMemberCount must be non-zero, so we can safely cast the base type to StructuralType
return ((StructuralType)_declaringType.BaseType).Members[index];
}
return base[relativeIndex];
}
set
{
throw EntityUtil.OperationOnReadOnlyCollection();
}
}
///
/// Gets an item from the collection with the given identity
///
/// The identity of the item to search for
/// An item from the collection
/// Thrown if identity argument passed in is null
/// Thrown if the Collection does not have an item with the given identity
/// Always thrown on setter
public override EdmMember this[string identity]
{
get
{
EdmMember item = null;
if (!TryGetValue(identity, false, out item))
{
throw EntityUtil.MemberInvalidIdentity(identity, "identity");
}
return item;
}
set
{
throw EntityUtil.OperationOnReadOnlyCollection();
}
}
///
/// Adds an item to the collection
///
/// The item to add to the list
/// Thrown if member argument is null
/// Thrown if the member passed in or the collection itself instance is in ReadOnly state
/// Thrown if the member that is being added already belongs to another MemberCollection
/// Thrown if the MemberCollection already contains a member with the same identity
public override void Add(EdmMember member)
{
// Make sure the member is valid for the add operation.
ValidateMemberForAdd(member, "member");
base.Add(member);
// Fix up the declaring type
member.ChangeDeclaringTypeWithoutCollectionFixup(_declaringType);
}
///
/// Determines if this collection contains an item of the given identity
///
/// The identity of the item to check for
/// True if the collection contains the item with the given identity
public override bool ContainsIdentity(string identity)
{
if (base.ContainsIdentity(identity))
{
return true;
}
// The item is not in this collection, check the base type member collection
EdmType baseType = _declaringType.BaseType;
if (baseType != null && ((StructuralType)baseType).Members.Contains(identity))
{
return true;
}
return false;
}
///
/// Find the index of an item
///
/// The item whose index is to be looked for
/// The index of the found item, -1 if not found
public override int IndexOf(EdmMember item)
{
// Try to get it from this collection, if found, then the relative index needs to be added with the number
// of members in the base type to get the absolute index
int relativeIndex = base.IndexOf(item);
if (relativeIndex != -1)
{
return relativeIndex + GetBaseTypeMemberCount();
}
// Try to find it in the base type
StructuralType baseType = _declaringType.BaseType as StructuralType;
if (baseType != null)
{
return baseType.Members.IndexOf(item);
}
return -1;
}
///
/// Copies the items in this collection to an array
///
/// The array to copy to
/// The index in the array at which to start the copy
/// Thrown if array argument is null
/// Thrown if the arrayIndex is less than zero
/// Thrown if the array argument passed in with respect to the arrayIndex passed in not big enough to hold the MemberCollection being copied
public override void CopyTo(EdmMember[] array, int arrayIndex)
{
// Check on the array index
if (arrayIndex < 0)
{
throw EntityUtil.ArgumentOutOfRange("arrayIndex");
}
// Check if the array together with the array index has enough room to copy
int baseTypeMemberCount = GetBaseTypeMemberCount();
if (base.Count + baseTypeMemberCount > array.Length - arrayIndex)
{
throw EntityUtil.Argument("arrayIndex");
}
// If the base type has any members, copy those first
if (baseTypeMemberCount > 0)
{
((StructuralType)_declaringType.BaseType).Members.CopyTo(array, arrayIndex);
}
base.CopyTo(array, arrayIndex + baseTypeMemberCount);
}
///
/// Gets an item from the collection with the given identity
///
/// The identity of the item to search for
/// Whether case is ignore in the search
/// An item from the collection, null if the item is not found
/// True an item is retrieved
/// if identity argument is null
public override bool TryGetValue(string identity, bool ignoreCase, out EdmMember item)
{
// See if it's in this collection
if (!base.TryGetValue(identity, ignoreCase, out item))
{
// Now go to the parent type to find it
EdmType baseType = _declaringType.BaseType;
if (baseType != null)
{
((StructuralType)baseType).Members.TryGetValue(identity, ignoreCase, out item);
}
}
return item != null;
}
///
/// Get the declared only members of a particular type
///
internal ReadOnlyMetadataCollection GetDeclaredOnlyMembers() where T : EdmMember
{
MetadataCollection newCollection = new MetadataCollection();
for (int i = 0; i < base.Count; i++)
{
T member = base[i] as T;
if (member != null)
{
newCollection.Add(member);
}
}
return newCollection.AsReadOnlyMetadataCollection();
}
///
/// Get the number of members the base type has. If the base type is not a structural type or has no
/// members, it returns 0
///
/// The number of members in the base type
private int GetBaseTypeMemberCount()
{
// The count of members is what in this collection plus base type's member collection
StructuralType baseType = _declaringType.BaseType as StructuralType;
if (baseType != null)
{
return baseType.Members.Count;
}
return 0;
}
///
/// Gets the index relative to this collection for the given index. For an index to really refers to something in
/// the base type, the return value is negative relative to this collection. For an index refers to something in this
/// collection, the return value is positive. In both cases, it's simply (index) - (base type member count)
///
/// The relative index
private int GetRelativeIndex(int index)
{
int baseTypeMemberCount = GetBaseTypeMemberCount();
int thisTypeMemberCount = base.Count;
// Check if the index is in range
if (index < 0 || index >= baseTypeMemberCount + thisTypeMemberCount)
{
throw EntityUtil.ArgumentOutOfRange("index");
}
return index - baseTypeMemberCount;
}
///
/// Checks if the given member already has a declaring type, if so, throw an exception
///
/// The member to check for
/// The name of the argument from the caller
private static void ThrowIfItHasDeclaringType(EdmMember member, string argumentName)
{
EntityUtil.GenericCheckArgumentNull(member, argumentName);
if (member.DeclaringType != null)
{
throw EntityUtil.MemberAlreadyBelongsToType(argumentName);
}
}
private void ValidateMemberForAdd(EdmMember member, string argumentName)
{
// Check to make sure the given member is not associated with another type
ThrowIfItHasDeclaringType(member, argumentName);
// Validate the item with the declaring type.
_declaringType.ValidateMemberForAdd(member);
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TreeViewTemplateSelector.cs
- LongValidatorAttribute.cs
- ToggleProviderWrapper.cs
- _AutoWebProxyScriptHelper.cs
- FontUnitConverter.cs
- SystemWebCachingSectionGroup.cs
- EntityDataSourceQueryBuilder.cs
- AdapterDictionary.cs
- MaskedTextProvider.cs
- HotSpot.cs
- RewritingSimplifier.cs
- LiteralText.cs
- ProxyElement.cs
- PropertyGridCommands.cs
- SoapFault.cs
- RuntimeHelpers.cs
- EntityCommandCompilationException.cs
- PrintPageEvent.cs
- Encoding.cs
- PathTooLongException.cs
- OperationExecutionFault.cs
- WSSecurityOneDotZeroSendSecurityHeader.cs
- RSAPKCS1KeyExchangeFormatter.cs
- COM2ComponentEditor.cs
- SyncMethodInvoker.cs
- FilteredDataSetHelper.cs
- Highlights.cs
- ConfigurationLocationCollection.cs
- RemotingHelper.cs
- SynchronizedPool.cs
- DataGridRowEventArgs.cs
- ImageMetadata.cs
- UrlPropertyAttribute.cs
- LabelInfo.cs
- PathParser.cs
- ClientConfigPaths.cs
- HtmlInputFile.cs
- TableLayoutColumnStyleCollection.cs
- DataBoundControlAdapter.cs
- ScrollViewerAutomationPeer.cs
- SizeFConverter.cs
- NamespaceMapping.cs
- DataControlImageButton.cs
- HtmlInputRadioButton.cs
- BidOverLoads.cs
- SoapReflectionImporter.cs
- WindowsScroll.cs
- Int64Storage.cs
- QueryableDataSource.cs
- ListView.cs
- DbProviderManifest.cs
- GradientSpreadMethodValidation.cs
- TextProperties.cs
- SafeUserTokenHandle.cs
- RangeValuePattern.cs
- DataGridRow.cs
- XmlILOptimizerVisitor.cs
- TableLayoutStyle.cs
- Validator.cs
- GeneratedView.cs
- HelpProvider.cs
- WriteFileContext.cs
- TheQuery.cs
- Operand.cs
- CreateUserErrorEventArgs.cs
- MenuItemBinding.cs
- PersonalizableTypeEntry.cs
- RelationshipWrapper.cs
- EventLogReader.cs
- UniqueEventHelper.cs
- UserPreferenceChangingEventArgs.cs
- NavigationPropertyAccessor.cs
- ToolTipAutomationPeer.cs
- SqlUserDefinedTypeAttribute.cs
- MouseGestureValueSerializer.cs
- URLIdentityPermission.cs
- TextContainerChangeEventArgs.cs
- ThicknessAnimationBase.cs
- Button.cs
- ZeroOpNode.cs
- TypeDelegator.cs
- UnaryNode.cs
- EastAsianLunisolarCalendar.cs
- RemotingConfiguration.cs
- SafeThreadHandle.cs
- TraceHandler.cs
- ComponentRenameEvent.cs
- QueryCacheKey.cs
- ProcessHostFactoryHelper.cs
- LinearKeyFrames.cs
- MemoryMappedViewStream.cs
- RSAOAEPKeyExchangeFormatter.cs
- ObjectCacheHost.cs
- StorageAssociationSetMapping.cs
- EFColumnProvider.cs
- TableAutomationPeer.cs
- ArcSegment.cs
- AtomServiceDocumentSerializer.cs
- Logging.cs
- uribuilder.cs