public static void Expose(this IScriptExecutionContext executionContext,IScriptObjectProvider objectProvider)
        {
            var assemblies = objectProvider.Assemblies ?? Enumerable.Empty<Assembly>();
            var namespaces = objectProvider.Namespaces ?? Enumerable.Empty<string>();

            foreach( var assembly in assemblies )
            {
                executionContext.AddReference(assembly);
            }

            foreach( var namespaceName in namespaces )
            {
                executionContext.Import(namespaceName);
            }

            executionContext.Expose(objectProvider.ObjectName,objectProvider.ObjectInstance);
        }
        /// <summary>
        /// Adds the assemblies.
        /// </summary>
        /// <param name="instance">The instance.</param>
        /// <param name="assembliesPath">The assemblies path.</param>
        /// <param name="assemblies">The assemblies.</param>
        public static void AddAssemblies(
            this Project instance, 
            string assembliesPath, 
            IEnumerable<string> assemblies)
        {
            string[] enumerable = assemblies as string[] ?? assemblies.ToArray();

            TraceService.WriteLine("ProjectExtensions::AddAssemblies project=" + instance.Name + " assembly count=" + enumerable.Count());

            foreach (string path in enumerable
                .Select(assembly => string.Format(
                "{0}{1}.dll",
                assembliesPath,
                assembly)))
            {
                if (File.Exists(path))
                {
                    instance.AddReference(path);
                }
            }
        }
        /// <summary>
        /// Adds the reference.
        /// </summary>
        /// <param name="instance">The instance.</param>
        /// <param name="destinationFolder">The destination folder.</param>
        /// <param name="destination">The destination.</param>
        /// <param name="source">The source.</param>
        /// <returns>
        /// The Reference.
        /// </returns>
        public static Reference AddReference(
            this Project instance,
            string destinationFolder,
            string destination,
            string source)
        {
            TraceService.WriteLine("ProjectExtensions::AddReference project=" + instance.Name);
            TraceService.WriteLine("Source=" + source);

            Reference reference = null;

            if (destination.EndsWith(";"))
            {
                destination = destination.TrimEnd(';');
            }

            if (destination.EndsWith(".dll") == false)
            {
                destination += ".dll";
            }

            if (source.EndsWith(";"))
            {
                source = source.TrimEnd(';');
            }

            if (source.EndsWith(".dll") == false)
            {
                source += ".dll";
            }

            //// only do if destination file doesn't exist
            if (File.Exists(destination) == false)
            {
                //// the directory may not exist - if so create it!
                string directory = Path.GetDirectoryName(destination);

                if (directory != null)
                {
                    if (Directory.Exists(directory) == false)
                    {
                        Directory.CreateDirectory(directory);
                    }
                }

                //// reference the source and dont copy the file!
                reference = instance.AddReference(source);
            }

            return reference;
        }
 public static int AddReferenceInternal(this IReferencable referencable)
 {
     return referencable.AddReference();
 }