Files
mono/mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/ObjectLayer/ObjectItemLoadingSessionData.cs
T
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

201 lines
9.6 KiB
C#

//---------------------------------------------------------------------
// <copyright file="ObjectItemLoadingSessionData.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Reflection;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
namespace System.Data.Metadata.Edm
{
internal sealed class ObjectItemLoadingSessionData
{
private Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader> _loaderFactory;
// all the types that we encountered while loading - this may contain types from various assemblies
private readonly Dictionary<string, EdmType> _typesInLoading;
//
private bool _conventionBasedRelationshipsAreLoaded = false;
private LoadMessageLogger _loadMessageLogger;
// list of errors encountered during loading
private readonly List<EdmItemError> _errors;
// keep the list of new assemblies that got loaded in this load assembly call. The reason why we need to keep a seperate
// list of assemblies is that we keep track of errors, and if there are no errors, only then do we add the list of assemblies
// to the global cache. Hence global cache is never polluted with invalid assemblies
private readonly Dictionary<Assembly, MutableAssemblyCacheEntry> _listOfAssembliesLoaded = new Dictionary<Assembly, MutableAssemblyCacheEntry>();
// List of known assemblies - this list is initially passed by the caller and we keep adding to it, as and when we load
// an assembly
private readonly KnownAssembliesSet _knownAssemblies;
private readonly LockedAssemblyCache _lockedAssemblyCache;
private readonly HashSet<ObjectItemAssemblyLoader> _loadersThatNeedLevel1PostSessionProcessing;
private readonly HashSet<ObjectItemAssemblyLoader> _loadersThatNeedLevel2PostSessionProcessing;
private readonly EdmItemCollection _edmItemCollection;
private Dictionary<string, KeyValuePair<EdmType, int>> _conventionCSpaceTypeNames;
private Dictionary<EdmType, EdmType> _cspaceToOspace;
private object _originalLoaderCookie;
internal Dictionary<string, EdmType> TypesInLoading { get { return _typesInLoading; } }
internal Dictionary<Assembly, MutableAssemblyCacheEntry> AssembliesLoaded { get { return _listOfAssembliesLoaded; } }
internal List<EdmItemError> EdmItemErrors { get { return _errors; } }
internal KnownAssembliesSet KnownAssemblies { get { return _knownAssemblies; } }
internal LockedAssemblyCache LockedAssemblyCache { get { return _lockedAssemblyCache; } }
internal EdmItemCollection EdmItemCollection { get { return _edmItemCollection; } }
internal Dictionary<EdmType, EdmType> CspaceToOspace { get { return _cspaceToOspace; } }
internal bool ConventionBasedRelationshipsAreLoaded
{
get { return _conventionBasedRelationshipsAreLoaded; }
set { _conventionBasedRelationshipsAreLoaded = value; }
}
internal LoadMessageLogger LoadMessageLogger
{
get
{
return this._loadMessageLogger;
}
}
// dictionary of types by name (not including namespace), we also track duplicate names
// so if one of those types is used we can log an error
internal Dictionary<string, KeyValuePair<EdmType, int>> ConventionCSpaceTypeNames
{
get
{
if (_edmItemCollection != null && _conventionCSpaceTypeNames == null)
{
_conventionCSpaceTypeNames = new Dictionary<string, KeyValuePair<EdmType, int>>();
// create the map and cache it
foreach (var edmType in _edmItemCollection.GetItems<EdmType>())
{
if ((edmType is StructuralType && edmType.BuiltInTypeKind != BuiltInTypeKind.AssociationType) || Helper.IsEnumType(edmType))
{
KeyValuePair<EdmType, int> pair;
if (_conventionCSpaceTypeNames.TryGetValue(edmType.Name, out pair))
{
_conventionCSpaceTypeNames[edmType.Name] = new KeyValuePair<EdmType, int>(pair.Key, pair.Value + 1);
}
else
{
pair = new KeyValuePair<EdmType, int>(edmType, 1);
_conventionCSpaceTypeNames.Add(edmType.Name, pair);
}
}
}
}
return _conventionCSpaceTypeNames;
}
}
internal Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader> ObjectItemAssemblyLoaderFactory
{
get { return _loaderFactory; }
set
{
if (_loaderFactory != value)
{
Debug.Assert(_loaderFactory == null || _typesInLoading.Count == 0, "Only reset the factory after types have not been loaded or load from the cache");
_loaderFactory = value;
}
}
}
internal object LoaderCookie
{
get
{
// be sure we get the same factory/cookie as we had before... if we had one
if (_originalLoaderCookie != null)
{
Debug.Assert(_loaderFactory == null ||
(object)_loaderFactory == _originalLoaderCookie, "The loader factory should determine the next loader, so we should always have the same loader factory");
return _originalLoaderCookie;
}
return _loaderFactory;
}
}
internal ObjectItemLoadingSessionData(KnownAssembliesSet knownAssemblies, LockedAssemblyCache lockedAssemblyCache, EdmItemCollection edmItemCollection, Action<String> logLoadMessage, object loaderCookie)
{
Debug.Assert(loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "This is a bad loader cookie");
_typesInLoading = new Dictionary<string, EdmType>(StringComparer.Ordinal);
_errors = new List<EdmItemError>();
_knownAssemblies = knownAssemblies;
_lockedAssemblyCache = lockedAssemblyCache;
_loadersThatNeedLevel1PostSessionProcessing = new HashSet<ObjectItemAssemblyLoader>();
_loadersThatNeedLevel2PostSessionProcessing = new HashSet<ObjectItemAssemblyLoader>();
_edmItemCollection = edmItemCollection;
_loadMessageLogger = new LoadMessageLogger(logLoadMessage);
_cspaceToOspace = new Dictionary<EdmType, EdmType>();
_loaderFactory = (Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>)loaderCookie;
_originalLoaderCookie = loaderCookie;
if (_loaderFactory == ObjectItemConventionAssemblyLoader.Create && _edmItemCollection != null)
{
foreach (KnownAssemblyEntry entry in _knownAssemblies.GetEntries(_loaderFactory, edmItemCollection))
{
foreach (EdmType type in entry.CacheEntry.TypesInAssembly.OfType<EdmType>())
{
if (Helper.IsEntityType(type))
{
ClrEntityType entityType = (ClrEntityType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem<StructuralType>(entityType.CSpaceTypeName), entityType);
}
else if (Helper.IsComplexType(type))
{
ClrComplexType complexType = (ClrComplexType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem<StructuralType>(complexType.CSpaceTypeName), complexType);
}
else if(Helper.IsEnumType(type))
{
ClrEnumType enumType = (ClrEnumType)type;
_cspaceToOspace.Add(_edmItemCollection.GetItem<EnumType>(enumType.CSpaceTypeName), enumType);
}
else
{
Debug.Assert(Helper.IsAssociationType(type));
_cspaceToOspace.Add(_edmItemCollection.GetItem<StructuralType>(type.FullName), type);
}
}
}
}
}
internal void RegisterForLevel1PostSessionProcessing(ObjectItemAssemblyLoader loader)
{
_loadersThatNeedLevel1PostSessionProcessing.Add(loader);
}
internal void RegisterForLevel2PostSessionProcessing(ObjectItemAssemblyLoader loader)
{
_loadersThatNeedLevel2PostSessionProcessing.Add(loader);
}
internal void CompleteSession()
{
foreach (ObjectItemAssemblyLoader loader in _loadersThatNeedLevel1PostSessionProcessing)
{
loader.OnLevel1SessionProcessing();
}
foreach (ObjectItemAssemblyLoader loader in _loadersThatNeedLevel2PostSessionProcessing)
{
loader.OnLevel2SessionProcessing();
}
}
}
}