Build a COM Visible .NET DLL and a non COM Visible DLL in Build Process?

You can create additional configuration to your project. For this configuration define some definition (e.g. COM_VISIBLE). This can be defined in Project Properties->Build->Conditional compilation symbols

Then, in AssemblyInfo.cs you may use #if directive:

#if COM_VISIBLE
    [assembly:ComVisible(true)]
#endif 

Here is one option -- add a second project to your solution.

The first project would be an implementation of the non-COM visible DLL.

The second project would reference the first, and contains a class which is derived from your first class (which implements the COM methods you want to expose). Since the first class already implements all of your COM-exposed interface elements, you just have to declare the second class as implementing the first one, like so:

namespace ClassLibrary2
{
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    [Guid("BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB")]
    public interface MyCOMInterface
    {
        void MyMethod();
    }

    [ComVisible(true)]
    [Guid("AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")]
    [ClassInterface(ClassInterfaceType.None)]
    public class Class2 : ClassLibrary1.Class1, MyCOMInterface
    {
        //No implementation is needed here because we're
        //just exposing Class1's methods to COM.
    }
}

By adding a second project, your solution can generate both DLLs in one build.

Just as an aside: you can reference a COM exposed .NET DLL, just as you would any other. That is to say, other .NET projects don't care whether a DLL's methods are exposed to COM-- they can still use all of the DLL's public methods. Using the same DLL, you can export some methods as COM, and have some of them relegated to .NET use only.

I mention this, because you didn't specify the reason behind this architecture.