internal static void ImportNamespaces6(CodeNamespace codeNamespace, Type[] pTypes)
        {
            Hashtable hashtable = new Hashtable();
            object dummy = new object();
            int num6;
            foreach (Type type in pTypes)
            {
                string fullName = type.FullName;
                if ((num6 = fullName.LastIndexOf('.')) > 0)
                {
                    hashtable[fullName.Substring(0, num6)] = dummy;
                }
            }
            // key are unique
            foreach (String key in hashtable.Keys)
            {
                codeNamespace.Imports.Add(new CodeNamespaceImport(key));
            }
        }

        public static void AddCodeNamespaces(Type[] pTypes)
        {
            CodeNamespaceImport[] uniqueKeys = pTypes
                .Where(t => t.FullName.LastIndexOf('.') > 0)
                .Select(n => n.FullName.Substring(0, n.FullName.LastIndexOf('.')))
                .Distinct() // ? slow/many?
                .Select(n => new CodeNamespaceImport(n))
                .ToArray()
                ;

            CodeNamespace.Imports.AddRange(uniqueKeys);
        }

using System;
using System.Linq;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.CodeDom;
using System.Diagnostics;

namespace Xsd_a.Tests
{
    [TestClass]
    public class UnitTest2
    {
        const Int32 TopLimit = 10000;
        Type[] types;

        [TestMethod]
        public void TestMethod1()
        {
            List<Type> typeslist = new List<Type>();
            Type[] types1 = typeof(System.String).Assembly.GetTypes();
            typeslist.AddRange(types1);
            Type[] types2 = typeof(System.Xml.Serialization.XmlAttributeAttribute).Assembly.GetTypes();
            typeslist.AddRange(types2);

            types = new Type[typeslist.Count];
            typeslist.CopyTo(types, 0);

            Debug.Print("Total types: " + types.Length + " (" + TopLimit + " cycles)");

            Stopwatch sw = new Stopwatch();

            // Force LINQ compilation & load
            CodeNamespaceImport[] imports0 = LinqNS.Model(0, types);

            CodeNamespaceImport[] imports = null;
            for (int model = 1; model <= 4; ++model)
            {
                sw.Restart();
                for (int loop = 0; loop <= TopLimit; ++loop)
                {
                    imports = LinqNS.Model(model, types);
                }
                sw.Stop();
                Debug.Print("Linq model " + model + " : " + sw.ElapsedMilliseconds + " ms. Items = " + imports.Length);
            }
        }
    }

    internal static class LinqNS
    {
        public static CodeNamespaceImport[] Model(int pModel, Type[] pTypes)
        {
            CodeNamespaceImport[] uniqueKeys = null;
            
            switch (pModel)
            {
                case 0:
                    // to force compilation
                    uniqueKeys = pTypes
                        .Where(t => t.FullName.LastIndexOf('.') > 0)
                        .Select(n => n.FullName.Substring(0, n.FullName.LastIndexOf('.')))
                        .Distinct()
                        .Select(n => new CodeNamespaceImport(n))
                        .ToArray()
                        ;
                    break;

                case 1:
                    uniqueKeys = pTypes
                        .Where(t => t.FullName.LastIndexOf('.') > 0)
                        .Select(n => n.FullName.Substring(0, n.FullName.LastIndexOf('.')))
                        .Distinct()
                        .Select(n => new CodeNamespaceImport(n))
                        .ToArray()
                        ;
                    break;

                case 2:
                    var selection2 = pTypes
                        .Where(t => t.FullName.LastIndexOf('.') > 0)
                        .Select(n => n.FullName.Substring(0, n.FullName.LastIndexOf('.')))
                        ;
                    uniqueKeys = new HashSet<string>(selection2).Select(n => new CodeNamespaceImport(n)).ToArray();
                    break;

                case 3:
                    var selection3 = pTypes
                        .Select(x => new { LastIndexOf = x.FullName.LastIndexOf('.'), FullName = x.FullName })
                        .Where(t => t.LastIndexOf > 0)
                        .Select(n => n.FullName.Substring(0, n.LastIndexOf))
                        ;
                    uniqueKeys = new HashSet<string>(selection3).Select(n => new CodeNamespaceImport(n)).ToArray();
                    break;

                case 4:
                    var selection4 = pTypes
                        .Select(x => x.Namespace)
                        ;
                    uniqueKeys = new HashSet<string>(selection4).Select(n => new CodeNamespaceImport(n)).ToArray();
                    break;

                default:
                    break;

            }
            // enshure accessible
            foreach(CodeNamespaceImport imp in uniqueKeys)
            {
                string ns = imp.Namespace;
            }
            return uniqueKeys;
        }
    }
}

                case 5:
                    var selection5 = pTypes
                        .Where(x => x.Namespace != null)
                        .Select(x => x.Namespace)
                        ;
                    uniqueKeys = new HashSet<string>(selection5).Select(n => new CodeNamespaceImport(n)).ToArray();
                    break;

        internal static void AddImports5(CodeNamespace codeNamespace, Type[] pTypes)
        {
            HashSet<string> hashset = new HashSet<String>();
            foreach (Type type in pTypes)
            {
                if (type.Namespace != null)
                {
                    hashset.Add(type.Namespace);
                }
            }
            // key are unique
            foreach (String s in hashset)
            {
                codeNamespace.Imports.Add(new CodeNamespaceImport(s));
            }
        }