internal static ObjectItemAssemblyLoader CreateLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) { ImmutableAssemblyCacheEntry cacheEntry; // KnownAssembly -> NoOp // Inside the LockedAssemblyCache means it is an attribute based assembly -> Cachedassembly // Inside the OcCache on EdmItemCollection -> cachedassembly // If none of above, setup the LoaderFactory based on the current assembly and EdmItemCollection if (sessionData.KnownAssemblies.Contains(assembly, sessionData.ObjectItemAssemblyLoaderFactory, sessionData.EdmItemCollection)) { return new ObjectItemNoOpAssemblyLoader(assembly, sessionData); } else if (sessionData.LockedAssemblyCache.TryGetValue(assembly, out cacheEntry)) { if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (cacheEntry.TypesInAssembly.Count != 0) { // we are loading based on attributes now sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create; } // if types in assembly are 0, don't commit to any loader yet } else if (sessionData.ObjectItemAssemblyLoaderFactory != ObjectItemAttributeAssemblyLoader.Create) { // we were loading in convention mode, and ran into an assembly that can't be loaded by convention // we know this because all cached assemblies are attribute based at the moment. sessionData.EdmItemErrors.Add( new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced(assembly.FullName))); } return new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData); } else if (sessionData.EdmItemCollection != null && sessionData.EdmItemCollection.ConventionalOcCache.TryGetConventionalOcCacheFromAssemblyCache( assembly, out cacheEntry)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create; return new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData); } else if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create; } else if (ObjectItemConventionAssemblyLoader.SessionContainsConventionParameters(sessionData)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create; } } if (sessionData.ObjectItemAssemblyLoaderFactory != null) { return sessionData.ObjectItemAssemblyLoaderFactory(assembly, sessionData); } return new ObjectItemNoOpAssemblyLoader(assembly, sessionData); }
internal static ObjectItemAssemblyLoader CreateLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) { ImmutableAssemblyCacheEntry cacheEntry; // KnownAssembly -> NoOp // Inside the LockedAssemblyCache means it is an attribute based assembly -> Cachedassembly // Inside the OcCache on EdmItemCollection -> cachedassembly // If none of above, setup the LoaderFactory based on the current assembly and EdmItemCollection if (sessionData.KnownAssemblies.Contains(assembly, sessionData.ObjectItemAssemblyLoaderFactory, sessionData.EdmItemCollection)) { return(new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); } else if (sessionData.LockedAssemblyCache.TryGetValue(assembly, out cacheEntry)) { if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (cacheEntry.TypesInAssembly.Count != 0) { // we are loading based on attributes now sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create; } // if types in assembly are 0, don't commit to any loader yet } else if (sessionData.ObjectItemAssemblyLoaderFactory != ObjectItemAttributeAssemblyLoader.Create) { // we were loading in convention mode, and ran into an assembly that can't be loaded by convention // we know this because all cached assemblies are attribute based at the moment. sessionData.EdmItemErrors.Add( new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced(assembly.FullName))); } return(new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData)); } else if (sessionData.EdmItemCollection != null && sessionData.EdmItemCollection.ConventionalOcCache.TryGetConventionalOcCacheFromAssemblyCache( assembly, out cacheEntry)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create; return(new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData)); } else if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create; } else if (ObjectItemConventionAssemblyLoader.SessionContainsConventionParameters(sessionData)) { sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create; } } if (sessionData.ObjectItemAssemblyLoaderFactory != null) { return(sessionData.ObjectItemAssemblyLoaderFactory(assembly, sessionData)); } return(new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); }
internal static void LoadAssembly( Assembly assembly, bool loadReferencedAssemblies, KnownAssembliesSet knownAssemblies, EdmItemCollection edmItemCollection, Action<String> logLoadMessage, ref object loaderCookie, out Dictionary<string, EdmType> typesInLoading, out List<EdmItemError> errors) { Debug.Assert( loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "This is a bad loader cookie"); typesInLoading = null; errors = null; using (var lockedAssemblyCache = AquireLockedAssemblyCache()) { var loadingData = new ObjectItemLoadingSessionData( knownAssemblies, lockedAssemblyCache, edmItemCollection, logLoadMessage, loaderCookie); LoadAssembly(assembly, loadReferencedAssemblies, loadingData); loaderCookie = loadingData.LoaderCookie; // resolve references to top level types (base types, navigation properties returns and associations, and complex type properties) loadingData.CompleteSession(); if (loadingData.EdmItemErrors.Count == 0) { // do the validation for the all the new types // Now, perform validation on all the new types var validator = new EdmValidator(); validator.SkipReadOnlyItems = true; validator.Validate(loadingData.TypesInLoading.Values, loadingData.EdmItemErrors); // Update the global cache if there are no errors if (loadingData.EdmItemErrors.Count == 0) { if (ObjectItemAssemblyLoader.IsAttributeLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { // we only cache items from the attribute loader globally, the // items loaded by convention will change depending on the cspace // provided. cspace will have a cache of it's own for assemblies UpdateCache(lockedAssemblyCache, loadingData.AssembliesLoaded); } else if (loadingData.EdmItemCollection != null && ObjectItemAssemblyLoader.IsConventionLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { UpdateCache(loadingData.EdmItemCollection, loadingData.AssembliesLoaded); } } } if (loadingData.TypesInLoading.Count > 0) { foreach (var edmType in loadingData.TypesInLoading.Values) { edmType.SetReadOnly(); } } // Update the out parameters once you are done with loading typesInLoading = loadingData.TypesInLoading; errors = loadingData.EdmItemErrors; } }
internal ObjectItemCachedAssemblyLoader( Assembly assembly, ImmutableAssemblyCacheEntry cacheEntry, ObjectItemLoadingSessionData sessionData) : base(assembly, (AssemblyCacheEntry)cacheEntry, sessionData) { }
internal ObjectItemConventionAssemblyLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) : base(assembly, new MutableAssemblyCacheEntry(), sessionData) { SessionData.RegisterForLevel1PostSessionProcessing(this); _factory = new ConventionOSpaceTypeFactory(this); }
internal static void LoadAssembly( Assembly assembly, bool loadReferencedAssemblies, KnownAssembliesSet knownAssemblies, EdmItemCollection edmItemCollection, Action <String> logLoadMessage, ref object loaderCookie, out Dictionary <string, EdmType> typesInLoading, out List <EdmItemError> errors) { Debug.Assert( loaderCookie == null || loaderCookie is Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "This is a bad loader cookie"); typesInLoading = null; errors = null; using (var lockedAssemblyCache = AquireLockedAssemblyCache()) { var loadingData = new ObjectItemLoadingSessionData( knownAssemblies, lockedAssemblyCache, edmItemCollection, logLoadMessage, loaderCookie); LoadAssembly(assembly, loadReferencedAssemblies, loadingData); loaderCookie = loadingData.LoaderCookie; // resolve references to top level types (base types, navigation properties returns and associations, and complex type properties) loadingData.CompleteSession(); if (loadingData.EdmItemErrors.Count == 0) { // do the validation for the all the new types // Now, perform validation on all the new types var validator = new EdmValidator(); validator.SkipReadOnlyItems = true; validator.Validate(loadingData.TypesInLoading.Values, loadingData.EdmItemErrors); // Update the global cache if there are no errors if (loadingData.EdmItemErrors.Count == 0) { if (ObjectItemAssemblyLoader.IsAttributeLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { // we only cache items from the attribute loader globally, the // items loaded by convention will change depending on the cspace // provided. cspace will have a cache of it's own for assemblies UpdateCache(lockedAssemblyCache, loadingData.AssembliesLoaded); } else if (loadingData.EdmItemCollection != null && ObjectItemAssemblyLoader.IsConventionLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { UpdateCache(loadingData.EdmItemCollection, loadingData.AssembliesLoaded); } } } if (loadingData.TypesInLoading.Count > 0) { foreach (var edmType in loadingData.TypesInLoading.Values) { edmType.SetReadOnly(); } } // Update the out parameters once you are done with loading typesInLoading = loadingData.TypesInLoading; errors = loadingData.EdmItemErrors; } }
private static void LoadAssembly( Assembly assembly, bool loadReferencedAssemblies, ObjectItemLoadingSessionData loadingData) { KnownAssemblyEntry entry; bool flag; if (loadingData.KnownAssemblies.TryGetKnownAssembly(assembly, (object)loadingData.ObjectItemAssemblyLoaderFactory, loadingData.EdmItemCollection, out entry)) { flag = !entry.ReferencedAssembliesAreLoaded && loadReferencedAssemblies; } else { ObjectItemAssemblyLoader.CreateLoader(assembly, loadingData).Load(); flag = loadReferencedAssemblies; } if (!flag) { return; } if (entry == null && loadingData.KnownAssemblies.TryGetKnownAssembly(assembly, (object)loadingData.ObjectItemAssemblyLoaderFactory, loadingData.EdmItemCollection, out entry) || entry != null) { entry.ReferencedAssembliesAreLoaded = true; } foreach (Assembly referencedAssembly in MetadataAssemblyHelper.GetNonSystemReferencedAssemblies(assembly)) { AssemblyCache.LoadAssembly(referencedAssembly, loadReferencedAssemblies, loadingData); } }
protected static void LoadAssemblies(IEnumerable <Assembly> assemblies, ObjectItemLoadingSessionData sessionData) { foreach (var assembly in assemblies) { var loader = CreateLoader(assembly, sessionData); loader.Load(); } }
protected ObjectItemAssemblyLoader( Assembly assembly, AssemblyCacheEntry cacheEntry, ObjectItemLoadingSessionData sessionData) { this._assembly = assembly; this._cacheEntry = cacheEntry; this._sessionData = sessionData; }
protected static void LoadAssemblies( IEnumerable <Assembly> assemblies, ObjectItemLoadingSessionData sessionData) { foreach (Assembly assembly in assemblies) { ObjectItemAssemblyLoader.CreateLoader(assembly, sessionData).Load(); } }
internal static ObjectItemAssemblyLoader Create( Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (!ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { return((ObjectItemAssemblyLoader) new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); } return((ObjectItemAssemblyLoader) new ObjectItemAttributeAssemblyLoader(assembly, sessionData)); }
internal static ObjectItemAssemblyLoader Create( Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (!ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { return((ObjectItemAssemblyLoader) new ObjectItemConventionAssemblyLoader(assembly, sessionData)); } sessionData.EdmItemErrors.Add(new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced((object)assembly.FullName))); return((ObjectItemAssemblyLoader) new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); }
internal static ObjectItemAssemblyLoader Create(Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (!ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { return(new ObjectItemConventionAssemblyLoader(assembly, sessionData)); } // we were loading in convention mode, and ran into an assembly that can't be loaded by convention sessionData.EdmItemErrors.Add( new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced(assembly.FullName))); return(new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); }
internal static void LoadAssembly( Assembly assembly, bool loadReferencedAssemblies, KnownAssembliesSet knownAssemblies, EdmItemCollection edmItemCollection, Action <string> logLoadMessage, ref object loaderCookie, out Dictionary <string, EdmType> typesInLoading, out List <EdmItemError> errors) { typesInLoading = (Dictionary <string, EdmType>)null; errors = (List <EdmItemError>)null; using (LockedAssemblyCache lockedAssemblyCache = AssemblyCache.AquireLockedAssemblyCache()) { ObjectItemLoadingSessionData loadingData = new ObjectItemLoadingSessionData(knownAssemblies, lockedAssemblyCache, edmItemCollection, logLoadMessage, loaderCookie); AssemblyCache.LoadAssembly(assembly, loadReferencedAssemblies, loadingData); loaderCookie = loadingData.LoaderCookie; loadingData.CompleteSession(); if (loadingData.EdmItemErrors.Count == 0) { new EdmValidator() { SkipReadOnlyItems = true }.Validate <EdmType>((IEnumerable <EdmType>)loadingData.TypesInLoading.Values, loadingData.EdmItemErrors); if (loadingData.EdmItemErrors.Count == 0) { if (ObjectItemAssemblyLoader.IsAttributeLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { AssemblyCache.UpdateCache(lockedAssemblyCache, loadingData.AssembliesLoaded); } else if (loadingData.EdmItemCollection != null && ObjectItemAssemblyLoader.IsConventionLoader(loadingData.ObjectItemAssemblyLoaderFactory)) { AssemblyCache.UpdateCache(loadingData.EdmItemCollection, loadingData.AssembliesLoaded); } } } if (loadingData.TypesInLoading.Count > 0) { foreach (MetadataItem metadataItem in loadingData.TypesInLoading.Values) { metadataItem.SetReadOnly(); } } typesInLoading = loadingData.TypesInLoading; errors = loadingData.EdmItemErrors; } }
internal static ObjectItemAssemblyLoader CreateLoader( Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (sessionData.KnownAssemblies.Contains(assembly, (object)sessionData.ObjectItemAssemblyLoaderFactory, sessionData.EdmItemCollection)) { return((ObjectItemAssemblyLoader) new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); } ImmutableAssemblyCacheEntry cacheEntry; if (sessionData.LockedAssemblyCache.TryGetValue(assembly, out cacheEntry)) { if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (cacheEntry.TypesInAssembly.Count != 0) { sessionData.ObjectItemAssemblyLoaderFactory = new Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>(ObjectItemAttributeAssemblyLoader.Create); } } else if (sessionData.ObjectItemAssemblyLoaderFactory != new Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>(ObjectItemAttributeAssemblyLoader.Create)) { sessionData.EdmItemErrors.Add(new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced((object)assembly.FullName))); } return((ObjectItemAssemblyLoader) new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData)); } if (sessionData.EdmItemCollection != null && sessionData.EdmItemCollection.ConventionalOcCache.TryGetConventionalOcCacheFromAssemblyCache(assembly, out cacheEntry)) { sessionData.ObjectItemAssemblyLoaderFactory = new Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>(ObjectItemConventionAssemblyLoader.Create); return((ObjectItemAssemblyLoader) new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData)); } if (sessionData.ObjectItemAssemblyLoaderFactory == null) { if (ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { sessionData.ObjectItemAssemblyLoaderFactory = new Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>(ObjectItemAttributeAssemblyLoader.Create); } else if (ObjectItemConventionAssemblyLoader.SessionContainsConventionParameters(sessionData)) { sessionData.ObjectItemAssemblyLoaderFactory = new Func <Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>(ObjectItemConventionAssemblyLoader.Create); } } if (sessionData.ObjectItemAssemblyLoaderFactory != null) { return(sessionData.ObjectItemAssemblyLoaderFactory(assembly, sessionData)); } return((ObjectItemAssemblyLoader) new ObjectItemNoOpAssemblyLoader(assembly, sessionData)); }
protected static void LoadAssemblies(IEnumerable<Assembly> assemblies, ObjectItemLoadingSessionData sessionData) { foreach (var assembly in assemblies) { var loader = CreateLoader(assembly, sessionData); loader.Load(); } }
internal ObjectItemNoOpAssemblyLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) : base(assembly, new MutableAssemblyCacheEntry(), sessionData) { }
internal static ObjectItemAssemblyLoader Create(Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (!ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly)) { return new ObjectItemConventionAssemblyLoader(assembly, sessionData); } else { // we were loading in convention mode, and ran into an assembly that can't be loaded by convention sessionData.EdmItemErrors.Add( new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced(assembly.FullName))); return new ObjectItemNoOpAssemblyLoader(assembly, sessionData); } }
internal static bool SessionContainsConventionParameters(ObjectItemLoadingSessionData sessionData) { return sessionData.EdmItemCollection != null; }
internal ObjectItemConventionAssemblyLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) : base(assembly, new MutableAssemblyCacheEntry(), sessionData) { Debug.Assert(Create == sessionData.ObjectItemAssemblyLoaderFactory, "Why is there a different factory creating this class"); SessionData.RegisterForLevel1PostSessionProcessing(this); }
internal static bool SessionContainsConventionParameters(ObjectItemLoadingSessionData sessionData) { return(sessionData.EdmItemCollection != null); }
internal ObjectItemAttributeAssemblyLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData) : base(assembly, new MutableAssemblyCacheEntry(), sessionData) { Debug.Assert(Create == sessionData.ObjectItemAssemblyLoaderFactory, "Why is there a different factory creating this class"); }
protected ObjectItemAssemblyLoader(Assembly assembly, AssemblyCacheEntry cacheEntry, ObjectItemLoadingSessionData sessionData) { _assembly = assembly; _cacheEntry = cacheEntry; _sessionData = sessionData; }
private static void LoadAssembly(Assembly assembly, bool loadReferencedAssemblies, ObjectItemLoadingSessionData loadingData) { // Check if the assembly is already loaded KnownAssemblyEntry entry; var shouldLoadReferences = false; if (loadingData.KnownAssemblies.TryGetKnownAssembly( assembly, loadingData.ObjectItemAssemblyLoaderFactory, loadingData.EdmItemCollection, out entry)) { shouldLoadReferences = !entry.ReferencedAssembliesAreLoaded && loadReferencedAssemblies; } else { var loader = ObjectItemAssemblyLoader.CreateLoader(assembly, loadingData); loader.Load(); shouldLoadReferences = loadReferencedAssemblies; } if (shouldLoadReferences) { if (entry == null && loadingData.KnownAssemblies.TryGetKnownAssembly( assembly, loadingData.ObjectItemAssemblyLoaderFactory, loadingData.EdmItemCollection, out entry) || entry != null) { entry.ReferencedAssembliesAreLoaded = true; } Debug.Assert(entry != null, "we should always have an entry, why don't we?"); // We will traverse through all the statically linked assemblies and their dependencies. // Only assemblies with the EdmSchemaAttribute will be loaded and rest will be ignored // Even if the schema attribute is missing, we should still check all the dependent assemblies // any of the dependent assemblies can have the schema attribute // After the given assembly has been loaded, check on the flag in _knownAssemblies to see if it has already // been recursively loaded. The flag can be true if it was already loaded before this function was called foreach (var referencedAssembly in MetadataAssemblyHelper.GetNonSystemReferencedAssemblies(assembly)) { // filter out "known" assemblies to prevent unnecessary loading // recursive call LoadAssembly(referencedAssembly, loadReferencedAssemblies, loadingData); } } }
internal ObjectItemNoOpAssemblyLoader( Assembly assembly, ObjectItemLoadingSessionData sessionData) : base(assembly, (AssemblyCacheEntry) new MutableAssemblyCacheEntry(), sessionData) { }
internal static ObjectItemAssemblyLoader Create(Assembly assembly, ObjectItemLoadingSessionData sessionData) { if (IsSchemaAttributePresent(assembly)) { return new ObjectItemAttributeAssemblyLoader(assembly, sessionData); } else { return new ObjectItemNoOpAssemblyLoader(assembly, sessionData); } }
internal ObjectItemCachedAssemblyLoader( Assembly assembly, ImmutableAssemblyCacheEntry cacheEntry, ObjectItemLoadingSessionData sessionData) : base(assembly, cacheEntry, sessionData) { }