代码有小小整理过

namespace CodeGenerator
{
    using Microsoft.VisualStudio.Shell.Interop;
    using System;
    using System.Runtime.InteropServices;

    internal abstract class BaseCodeGenerator : IVsSingleFileGenerator
    {
        private string codeFileNameSpace = string.Empty;
        private string codeFilePath = string.Empty;
        private IVsGeneratorProgress codeGeneratorProgress;

        protected BaseCodeGenerator()
        {
        }

        public abstract int DefaultExtension(out string extension);
        public int Generate(string wszInputFilePath, string bstrInputFileContents, string wszDefaultNamespace, IntPtr[] pbstrOutputFileContents, out uint pbstrOutputFileContentSize, IVsGeneratorProgress pGenerateProgress)
        {
            if (bstrInputFileContents == null)
            {
                throw new ArgumentNullException(bstrInputFileContents);
            }
            this.codeFilePath = wszInputFilePath;
            this.codeFileNameSpace = wszDefaultNamespace;
            this.codeGeneratorProgress = pGenerateProgress;
            byte[] source = this.GenerateCode(wszInputFilePath, bstrInputFileContents);
            if (source == null)
            {
                pbstrOutputFileContents = null;
                pbstrOutputFileContentSize = 0;
            }
            else
            {
                pbstrOutputFileContentSize = (uint) source.Length;
                pbstrOutputFileContents[0] = Marshal.AllocCoTaskMem(source.Length);
                Marshal.Copy(source, 0, pbstrOutputFileContents[0], source.Length);
            }
            return 0;
        }

        protected abstract byte[] GenerateCode(string inputFileName, string inputFileContent);
        protected virtual void GeneratorErrorCallback(int warning, uint level, string message, uint line, uint column)
        {
            IVsGeneratorProgress codeGeneratorProgress = this.CodeGeneratorProgress;
            if (codeGeneratorProgress != null)
            {
                codeGeneratorProgress.GeneratorError(warning, level, message, line, column);
            }
        }

        internal IVsGeneratorProgress CodeGeneratorProgress
        {
            get
            {
                return this.codeGeneratorProgress;
            }
        }

        protected string FileNameSpace
        {
            get
            {
                return this.codeFileNameSpace;
            }
        }

        protected string InputFilePath
        {
            get
            {
                return this.codeFilePath;
            }
        }
    }
}

namespace CodeGenerator
{
    using Microsoft.VisualStudio.OLE.Interop;
    using System;
    using System.CodeDom.Compiler;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Runtime.InteropServices;
    using System.Text;
    using Microsoft.VisualStudio.Shell;
    using Microsoft.VisualStudio.Shell.Interop;
    using System.Diagnostics.CodeAnalysis;
    using EnvDTE;
    using VsWebSite;
    using VSLangProj;
    using Microsoft.VisualStudio.Designer.Interfaces;
    using System.IO;

    public abstract class BaseCodeGeneratorWithSite : BaseCodeGenerator, IObjectWithSite
    {
        private CodeDomProvider codeDomProvider;
        private ServiceProvider serviceProvider;
        private object site;

        protected BaseCodeGeneratorWithSite()
        {
        }

        protected void AddReferenceDLLsToProject(ICollection<string> referenceDLLs)
        {
            string str = AddReferenceDLLToProject(this.SiteServiceProvider, referenceDLLs);
            if (!EmptyOrSpace(str))
            {
                this.GeneratorErrorCallback(0, 1, str, 0, 0);
            }
        }

        public static bool EmptyOrSpace(string str)
        {
            if (str != null)
            {
                return (0 >= str.Trim().Length);
            }
            return true;
        }

        private static object GetProjectObject(Project containingProject)
        {
            object obj2 = containingProject.Object;
            if (IsWebProject(containingProject) && (obj2 is VSWebSite))
            {
                return obj2;
            }
            if (obj2 is VSProject)
            {
                return obj2;
            }
            return null;
        }

        public static bool IsWebProject(Project p)
        {
            if (p == null)
            {
                return false;
            }
            return (p.Kind == "{E24C65DC-7377-472b-9ABA-BC803B73C61A}");
        }

        private static void AddReferenceToProjectObject(object projectObj, string referenceDll)
        {
            if (projectObj != null)
            {
                if (projectObj is VSWebSite)
                {
                    VSWebSite site = projectObj as VSWebSite;
                    site.References.AddFromGAC(referenceDll);
                }
                else if (projectObj is VSProject)
                {
                    VSProject project = projectObj as VSProject;
                    project.References.Add(referenceDll);
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Failure only of interest to devs")]
        public static string AddReferenceDLLToProject(System.IServiceProvider serviceProvider, ICollection<string> referenceDLL)
        {
            try
            {
                if (referenceDLL.Count == 0)
                {
                    return string.Empty;
                }
                object service = serviceProvider.GetService(typeof(ProjectItem));
                if (service == null)
                {
                    return "Failed to add reference dll.";
                }
                Project containingProject = ((ProjectItem)service).ContainingProject;
                if (containingProject == null)
                {
                    return "Failed to add reference dll.";
                }
                object projectObject = GetProjectObject(containingProject);
                if (projectObject == null)
                {
                    return "Failed to add reference dll.";
                }
                IVsHierarchy hierarchy = (IVsHierarchy)serviceProvider.GetService(typeof(IVsHierarchy));
                IVsProjectBuildSystem system = hierarchy as IVsProjectBuildSystem;
                if (system != null)
                {
                    system.StartBatchEdit();
                }
                try
                {
                    foreach (string str in referenceDLL)
                    {
                        AddReferenceToProjectObject(projectObject, str);
                    }
                    if (system != null)
                    {
                        system.EndBatchEdit();
                    }
                }
                catch
                {
                    if (system != null)
                    {
                        system.CancelBatchEdit();
                    }
                    return "Failed to add reference dll.";
                }
            }
            catch (Exception)
            {
                return "Failed to add reference dll.";
            }
            return string.Empty;
        }

        protected virtual string CreateExceptionMessage(Exception e)
        {
            StringBuilder builder = new StringBuilder();
            builder.Append((e.Message != null) ? e.Message : string.Empty);
            for (Exception exception = e.InnerException; exception != null; exception = exception.InnerException)
            {
                string message = exception.Message;
                if ((message != null) && (message.Length > 0))
                {
                    builder.Append(" ");
                    builder.Append(message);
                }
            }
            return builder.ToString();
        }

        public string GetGeneratedCodeFile(string inputFileName)
        {
            string extension = null;
            this.DefaultExtension(out extension);
            return Path.ChangeExtension(inputFileName, extension);
        }

        public override int DefaultExtension(out string extension)
        {
            CodeDomProvider codeProvider = this.CodeProvider;
            extension = "designer." + codeProvider.FileExtension;
            if (((extension != null) && (extension.Length > 0)) && (extension[0] != '.'))
            {
                extension = "." + extension;
            }
            return 0;
        }

        public byte[] StringToByteArray(string inputContents, Encoding encoding)
        {
            byte[] preamble = encoding.GetPreamble();
            byte[] bytes = encoding.GetBytes(inputContents);
            MemoryStream stream = new MemoryStream(preamble.Length + bytes.Length); 
            stream.Write(preamble, 0, preamble.Length);
            stream.Write(bytes, 0, bytes.Length);
            stream.Position = 0L;
            return stream.ToArray();
        }

        protected object GetService(Guid serviceGuid)
        {
            return this.SiteServiceProvider.GetService(serviceGuid);
        }

        protected object GetService(Type serviceType)
        {
            return this.SiteServiceProvider.GetService(serviceType);
        }

        public virtual void GetSite(ref Guid riid, out IntPtr pSite)
        {
            if (this.site == null)
            {
                throw new Win32Exception();
            }
            IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(this.site);
            pSite = IntPtr.Zero;
            try
            {
                Marshal.QueryInterface(iUnknownForObject, ref riid, out pSite);
            }
            finally
            {
                if (iUnknownForObject != IntPtr.Zero)
                {
                    Marshal.Release(iUnknownForObject);
                }
            }
            if (pSite == IntPtr.Zero)
            {
                throw new Win32Exception();
            }
        }

        public virtual void SetSite(object pUnkSite)
        {
            this.site = pUnkSite;
            this.codeDomProvider = null;
            this.serviceProvider = null;
        }

        public static CodeDomProvider GetCodeDomProviderFromServiceProvider(System.IServiceProvider sp)
        {
            if (sp == null)
            {
                return null;
            }
            ServiceInstance instance = new ServiceInstance(sp);
            IVSMDCodeDomProvider iVSMDCodeDomProvider = instance.IVSMDCodeDomProvider;
            if (iVSMDCodeDomProvider == null)
            {
                return null;
            }
            return (iVSMDCodeDomProvider.CodeDomProvider as CodeDomProvider);
        }

        protected virtual CodeDomProvider CodeProvider
        {
            get
            {
                if (this.codeDomProvider == null)
                {
                    try
                    {
                        this.codeDomProvider = GetCodeDomProviderFromServiceProvider(this.SiteServiceProvider);
                    }
                    catch
                    {
                        this.codeDomProvider = CodeDomProvider.CreateProvider("cs");
                    }
                }
                return this.codeDomProvider;
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException();
                }
                this.codeDomProvider = value;
            }
        }

        protected ServiceProvider SiteServiceProvider
        {
            get
            {
                if (this.serviceProvider == null)
                {
                    Microsoft.VisualStudio.OLE.Interop.IServiceProvider site = this.site as Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
                    this.serviceProvider = new ServiceProvider(site);
                }
                return this.serviceProvider;
            }
        }
    }
}

使用的时候重写GenerateCode方法即可