Пример #1
0
        /// <summary>
        /// Analyze dependent assemblies and connect there NetOffice API factories to the core runtime
        /// </summary>
        internal void LoadDependentAPIFactories()
        {
            if (!Parent.Settings.EnableAdHocLoading)
            {
                return;
            }

            foreach (DependentAssembly dependAssembly in DependentAssemblies)
            {
                if (!FactoryAssemblies.Contains(dependAssembly.Name))
                {
                    string fileName = PathBuilder.BuildLocalPathFromDependentAssembly(dependAssembly);
                    if (System.IO.File.Exists(fileName))
                    {
                        try
                        {
                            Assembly asssembly = Parent.CoreDomain.Load(fileName);
                            if (null != asssembly)
                            {
                                RecieveAssemblyFactory(asssembly.GetName().Name, asssembly);
                            }
                        }
                        catch (Exception exception)
                        {
                            Parent.Console.WriteException(exception);
                        }
                    }
                    else
                    {
                        Parent.Console.WriteLine(string.Format("Assembly {0} not found.", fileName));
                    }
                }
            }
        }
Пример #2
0
 /// <summary>
 /// Removes all factory informations from the instance
 /// </summary>
 internal void Clear()
 {
     lock (_thisLock)
     {
         FactoryAssemblies.Clear();
         DependentAssemblies.Clear();
     }
 }
Пример #3
0
        /// <summary>
        /// Recieve factory instance from assembly and add them to factory cache
        /// </summary>
        /// <param name="name">name of the assembly</param>
        /// <param name="assembly">assemmbly to recieve</param>
        /// <returns>array of dependend assemblies</returns>
        private string[] RecieveAssemblyFactory(string name, Assembly assembly)
        {
            if (false == Attributes.NetOfficeAssemblyAttribute.ContainsAttribute(assembly))
            {
                return(new string[0]);
            }

            ITypeFactory factoryInfo = FactoryAssemblies.FirstOrDefault(e => e.FactoryName == name);

            if (null == factoryInfo)
            {
                string targetTypeFactoryName = String.Format("NetOffice.{0}.{1}", name, "Tools.Expose.TypeFactory");

                List <string> dependAssemblies = new List <string>();
                Type          factoryInfoType  = assembly.GetType(targetTypeFactoryName, false);

                if (null == factoryInfoType)
                {
                    throw new NetOfficeException(String.Format("Unable to find {0} type factory", name));
                }

                factoryInfo = Activator.CreateInstance(factoryInfoType) as ITypeFactory;

                if (null == factoryInfo)
                {
                    throw new FactoryException(String.Format("Unexpected {0} type factory. Assembly {0}", name, assembly));
                }

                FactoryAssemblies.Add(factoryInfo);

                Parent.Console.WriteLine("NetOffice Core recieved factory:{0}:{1}", factoryInfo.Assembly.FullName, factoryInfo.Assembly.FullName);

                foreach (string itemDependency in factoryInfo.Dependencies)
                {
                    dependAssemblies.Add(itemDependency);
                }

                return(dependAssemblies.ToArray());
            }
            else
            {
                return(new string[0]);
            }
        }