Example #1
0
        private static AssemblyBuilderHelper GetAssemblyBuilder(Type type, string suffix)
        {
            var ab = GlobalAssemblyBuilder;

            if (ab == null)
            {
#if SILVERLIGHT
                var assemblyDir = ".";
#else
                var assemblyDir = AppDomain.CurrentDomain.BaseDirectory;

                // Dynamic modules are locationless, so ignore them.
                // _ModuleBuilder is the base type for both
                // ModuleBuilder and InternalModuleBuilder classes.
                //
                if (!(type.Module is ModuleBuilder) && type.Module.FullyQualifiedName != null && type.Module.FullyQualifiedName.IndexOf('<') < 0)
                {
                    assemblyDir = Path.GetDirectoryName(type.Module.FullyQualifiedName);
                }
#endif

                var fullName = type.FullName;

                if (type.IsGenericType)
                {
                    fullName = AbstractClassBuilder.GetTypeFullName(type);
                }

                fullName = fullName.Replace('<', '_').Replace('>', '_');

                ab = new AssemblyBuilderHelper(Path.Combine(assemblyDir, fullName + "." + suffix + ".dll"));
            }

            return(ab);
        }
Example #2
0
        private static AssemblyBuilderHelper GetAssemblyBuilder(Type type, string suffix)
        {
            AssemblyBuilderHelper ab = GlobalAssemblyBuilder;

            if (ab == null)
            {
                string assemblyDir = AppDomain.CurrentDomain.BaseDirectory;

                // Dynamic modules are locationless, so ignore them.
                // _ModuleBuilder is the base type for both
                // ModuleBuilder and InternalModuleBuilder classes.
                //
                if (!(type.Module is _ModuleBuilder))
                {
                    assemblyDir = Path.GetDirectoryName(type.Module.FullyQualifiedName);
                }

                string fullName = type.FullName;

                if (type.IsGenericType)
                {
                    fullName = AbstractClassBuilder.GetTypeFullName(type);
                }

                ab = new AssemblyBuilderHelper(assemblyDir + "\\" + fullName + "." + suffix + ".dll");
            }

            return(ab);
        }
        static AssemblyBuilderHelper GetAssemblyBuilder(Type type, string suffix)
        {
            var assemblyDir = AppDomain.CurrentDomain.BaseDirectory;

            // Dynamic modules are locationless, so ignore them.
            // _ModuleBuilder is the base type for both
            // ModuleBuilder and InternalModuleBuilder classes.
            //
            if (
#if !NETCOREAPP2_0 && !NETCOREAPP2_1 && !NETCOREAPP2_2
                !(type.Module is _ModuleBuilder) &&
#endif
                type.Module.FullyQualifiedName.IndexOf('<') < 0)
            {
                assemblyDir = Path.GetDirectoryName(type.Module.FullyQualifiedName);
            }

            var fullName = type.FullName;

            if (type.IsGenericTypeEx())
            {
                fullName = AbstractClassBuilder.GetTypeFullName(type);
            }

            Debug.Assert(fullName != null, $"{nameof(fullName)} != null");
            Debug.Assert(assemblyDir != null, $"{nameof(assemblyDir)} != null");

            fullName = fullName.Replace('<', '_').Replace('>', '_');

            return(new AssemblyBuilderHelper(Path.Combine(assemblyDir, $"{fullName}.{suffix}.dll")));
        }
Example #4
0
        public static TypeAccessor GetAccessor(Type originalType)
        {
            if (originalType == null)
            {
                throw new ArgumentNullException("originalType");
            }

            TypeAccessor accessor = (TypeAccessor)_accessors[originalType];

            if (accessor == null)
            {
                lock (_accessors.SyncRoot)
                {
                    accessor = (TypeAccessor)_accessors[originalType];

                    if (accessor == null)
                    {
                        if (IsAssociatedType(originalType))
                        {
                            return((TypeAccessor)_accessors[originalType]);
                        }

                        Type instanceType = IsClassBulderNeeded(originalType)? null: originalType;
                        Type accessorType = null;

                        if (_loadTypes)
                        {
                            Assembly originalAssembly = originalType.Assembly;
                            Assembly extensionAssembly;

                            if (_assemblies.Contains(originalAssembly))
                            {
                                extensionAssembly = (Assembly)_assemblies[originalAssembly];
                            }
                            else
                            {
                                extensionAssembly = LoadExtensionAssembly(originalAssembly);
                                _assemblies.Add(originalAssembly, extensionAssembly);
                            }

                            if (extensionAssembly != null)
                            {
                                if (instanceType == null)
                                {
                                    instanceType = extensionAssembly.GetType(
                                        AbstractClassBuilder.GetTypeName(originalType));
                                }

                                if (instanceType != null)
                                {
                                    accessorType = extensionAssembly.GetType(
                                        TypeAccessorBuilder.GetTypeAccessorClassName(instanceType));
                                }
                            }
                        }

                        if (accessorType == null)
                        {
                            if (instanceType == null)
                            {
                                instanceType = TypeFactory.GetType(originalType, new AbstractClassBuilder());
                            }

                            accessorType = TypeFactory.GetType(originalType, new TypeAccessorBuilder(instanceType, originalType));
                        }

                        accessor = (TypeAccessor)Activator.CreateInstance(accessorType);

                        _accessors[originalType] = accessor;

                        if (originalType != instanceType)
                        {
                            _accessors[instanceType] = accessor;
                        }
                    }
                }
            }

            return(accessor);
        }