DefaultAssemblyResolver.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Metadata / DefaultAssemblyResolver.cs / 1305376 / DefaultAssemblyResolver.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System.Reflection; 
using System.IO;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq; 
using System.Collections;
 
namespace System.Data.Metadata.Edm 
{
    internal class DefaultAssemblyResolver : MetadataArtifactAssemblyResolver 
    {
        internal override bool TryResolveAssemblyReference(AssemblyName refernceName, out Assembly assembly)
        {
            assembly = ResolveAssembly(refernceName); 
            return assembly != null;
        } 
 

        internal override IEnumerable GetWildcardAssemblies() 
        {
            return GetAllDiscoverableAssemblies();
        }
 
        internal Assembly ResolveAssembly(AssemblyName referenceName)
        { 
            Assembly assembly = null; 

            // look in the already loaded assemblies 
            foreach (Assembly current in GetAlreadyLoadedNonSystemAssemblies())
            {
                if (AssemblyName.ReferenceMatchesDefinition(referenceName, new AssemblyName(current.FullName)))
                { 
                    return current;
                } 
            } 

            // try to load this one specifically 
            if (assembly == null)
            {
                assembly = MetadataAssemblyHelper.SafeLoadReferencedAssembly(referenceName);
                if (assembly != null) 
                {
                    return assembly; 
                } 
            }
 
            // try all the discoverable ones
            TryFindWildcardAssemblyMatch(referenceName, out assembly);

            return assembly; 
        }
 
        private bool TryFindWildcardAssemblyMatch(AssemblyName referenceName, out Assembly assembly) 
        {
            Debug.Assert(referenceName != null); 

            foreach (Assembly current in GetAllDiscoverableAssemblies())
            {
                if (AssemblyName.ReferenceMatchesDefinition(referenceName, new AssemblyName(current.FullName))) 
                {
                    assembly = current; 
                    return true; 
                }
            } 

            assembly = null;
            return false;
        } 

 
        ///  
        /// Return all assemblies loaded in the current AppDomain that are not signed
        /// with the Microsoft Key. 
        /// 
        /// A list of assemblies
        private static IEnumerable GetAlreadyLoadedNonSystemAssemblies()
        { 
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            return assemblies.Where(a => a != null && !MetadataAssemblyHelper.ShouldFilterAssembly(a)); 
        } 

        ///  
        /// This method returns a list of assemblies whose contents depend on whether we
        /// are running in an ASP.NET environment. If we are indeed in a Web/ASP.NET
        /// scenario, we pick up the assemblies that all page compilations need to
        /// reference. If not, then we simply get the list of assemblies referenced by 
        /// the entry assembly.
        ///  
        /// A list of assemblies 
        private static IEnumerable GetAllDiscoverableAssemblies()
        { 
            Assembly assembly = Assembly.GetEntryAssembly();
            HashSet assemblyList = new HashSet(
                AssemblyComparer.Instance);
 
            foreach (Assembly loadedAssembly in GetAlreadyLoadedNonSystemAssemblies())
            { 
                assemblyList.Add(loadedAssembly); 
            }
 
            AspProxy aspProxy = new AspProxy();
            if (!aspProxy.IsAspNetEnvironment())
            {
                if (assembly == null) 
                {
                    return assemblyList; 
                } 

                assemblyList.Add(assembly); 

                foreach (Assembly referenceAssembly in MetadataAssemblyHelper.GetNonSystemReferencedAssemblies(assembly))
                {
                    assemblyList.Add(referenceAssembly); 
                }
 
                return assemblyList; 
            }
 
            if (aspProxy.HasBuildManagerType())
            {
                IEnumerable referencedAssemblies = aspProxy.GetBuildManagerReferencedAssemblies();
                // filter out system assemblies 
                if (referencedAssemblies != null)
                { 
                    foreach (Assembly referencedAssembly in referencedAssemblies) 
                    {
                        if (MetadataAssemblyHelper.ShouldFilterAssembly(referencedAssembly)) 
                        {
                            continue;
                        }
 
                        assemblyList.Add(referencedAssembly);
                    } 
                } 
            }
 
            return assemblyList.Where(a => a != null);
        }

        internal sealed class AssemblyComparer : IEqualityComparer 
        {
            // use singleton 
            private AssemblyComparer() { } 

            private static AssemblyComparer _instance = new AssemblyComparer(); 
            public static AssemblyComparer Instance{ get { return _instance; } }

            /// 
            /// if two assemblies have the same full name, we will consider them as the same. 
            /// for example,
            /// both of x and y have the full name as "{RES, Version=3.5.0.0, Culture=neutral, PublicKeyToken=null}", 
            /// although they are different instances since the ReflectionOnly field in them are different, we sitll 
            /// consider them as the same.
            ///  
            /// 
            /// 
            /// 
            public bool Equals(Assembly x, Assembly y) 
            {
                AssemblyName xname = new AssemblyName(x.FullName); 
                AssemblyName yname = new AssemblyName(y.FullName); 
                // return *true* when either the reference are the same
                // *or* the Assembly names are commutative equal 
                return object.ReferenceEquals(x, y)
                    || (AssemblyName.ReferenceMatchesDefinition(xname, yname)
                         && AssemblyName.ReferenceMatchesDefinition(yname, xname));
            } 

            public int GetHashCode(Assembly assembly) 
            { 
                return assembly.FullName.GetHashCode();
            } 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
DefaultAssemblyResolver.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
