{"id":3883,"date":"2010-05-03T11:08:00","date_gmt":"2010-05-03T11:08:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2010\/05\/03\/flexible-project-to-project-references\/"},"modified":"2019-02-18T18:45:32","modified_gmt":"2019-02-18T18:45:32","slug":"flexible-project-to-project-references","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/flexible-project-to-project-references\/","title":{"rendered":"Flexible Project-to-Project References"},"content":{"rendered":"

My name is Amit Mohindra and I am a Program Manager with the Visual C++ IDE team. In this post I would like to talk about project-to-project references. In VS2010 release we moved the C++ build and project system to be based on MSBuild. There is an excellent article written by Marian Luparu detailing the change and advantages of the new build\/project system (<\/font>http:\/\/blogs.msdn.com\/vcblog\/archive\/2008\/11\/20\/printf-hello-msbuild-n.aspx<\/font><\/a>).<\/font><\/p>\n

Project to Project references have existed ever since Visual Studio 6. However the term has evolved over the years. Native technologies used Project dependencies to define references prior to Visual Studio 8. With Visual Studio 8 native projects were able to define project to project references. <\/font><\/p>\n

\u201cProject to Project references\u201d defines the mechanism in which Project A creates a reference to Project B, by which Project A consumes the output of Project B to deliver on its functionality.  <\/span>This feature is consumed by users who have large source code bases, a solution with many large projects and input of one project is driven by the output of another project.<\/font><\/p>\n

Traditionally, there are three variables that control how project references work:<\/font><\/p>\n

<\/a><\/a><\/a><\/a>\u00b7<\/font>         <\/span><\/span><\/span>Ignore Import Library<\/font><\/font><\/span><\/span><\/span> (Set On the Referenced project)<\/font><\/h3>\n

Tells the linker not to try to link any .lib output generated from this build into any dependent project. This allows the project system to handle .dll files that do not produce a .lib file when built. If a project is dependent on another project that produces a DLL, the project system automatically will link the .lib file produced by that child project. This may not be needed by projects that are producing COM DLLs or resource-only DLLs; these DLLs do not have any meaningful exports. If a DLL has no exports, the linker will not generate a .lib file. If no export .lib file is present on the disk, and the project system tells the linker to link with this (missing) DLL, the link will fail. <\/font><\/p>\n

Use \u201cIgnore Import Library\u201d<\/b><\/span> to resolve this problem. When set to \u201cYes\u201d<\/b><\/span>, the project system will ignore the presence or absence of that .lib file and cause any project that is dependent on this project to not link with the nonexistent .lib file. <\/font><\/p>\n

<\/a><\/a><\/a><\/a><\/a>\u00b7<\/font>         <\/span><\/span><\/span><\/span><\/span><\/span><\/span>Link Library Dependencies<\/span><\/span><\/span><\/span> (Set On the Referencing project)<\/font><\/font><\/h3>\n

Gives you the choice of linking in the .lib files that are produced by dependent projects. Typically, you will want to link in the .lib file. If you don\u2019t want to consume the .lib file generated then just set this Linker setting to \u201cFalse\u201d.<\/font><\/p>\n

<\/a><\/a><\/a><\/a><\/a>\u00b7<\/font>         <\/span><\/span><\/span><\/span><\/span><\/span><\/span>Use Library Dependency Inputs<\/span><\/span><\/span><\/span> (Set On the Referencing project)<\/font><\/font><\/h3>\n

In a large project, when a dependent project produces a .lib file, incremental linking is disabled. If there are many dependent projects that produce .lib files, building the application can take a long time. When this property is set to Yes<\/b>, the project system links in the .obj files for .libs produced by dependent projects, thus enabling incremental linking.<\/font><\/p>\n

In this design however there were limitations and the design wasn\u2019t very flexible in allowing the project defining the reference to control the behavior. Consider the following very simple example:<\/font><\/p>\n

<\/font><\/font><\/p>\n

 <\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>Project A<\/span><\/b> defines project-to-project references to Project B<\/span><\/b> and Project C<\/span><\/b> (both Project B<\/span><\/b> and C <\/span><\/b>create .lib outputs). Project A<\/span><\/b> wants to only consume the library output of Project B<\/span><\/b> and not for Project<\/span><\/b> C<\/span><\/b>. <\/font><\/font><\/p>\n

o<\/font>   <\/span><\/span><\/span>In VS2008, this was achieved by creating references to Project A with \u201cLink Library Dependency\u201d property set to \u201cYes\u201d for Project A and subsequently setting \u201cIgnore Import Library\u201d for Project B<\/span><\/b> to \u201cNo\u201d.<\/font><\/p>\n

\u00a7<\/font>  <\/span><\/span><\/span>This approach however had a disadvantage in that if there was another Project D<\/span><\/b> referencing Project B<\/span><\/b> it would be limited by the \u201cIgnore Import Library\u201d property being set to \u201cNo\u201d. The scenario shown in diagram above was not achievable in VS2008.<\/font><\/p>\n

In VS2010 we have enabled the above scenario by supporting reference level metadata on the project references. Now you can set \u201cLink Library Dependencies\u201d and \u201cUse Library Dependency Inputs\u201d properties at the project reference level. To achieve the scenario above:<\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>Project A<\/span><\/b> will create a project reference to Project B<\/span><\/b> and Project C<\/span><\/b><\/font><\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>For the Project B<\/span><\/b> set the \u201cLink Library Dependencies\u201d property to \u201cFalse\u201d<\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>Project D<\/span><\/b> will create a project reference to Project B<\/span><\/b> and Project C<\/span><\/b>. In this case the global defaults for the properties (\u201cLink Library Dependencies\u201d set to \u201cTrue\u201d and \u201cUse Library Dependency Inputs\u201d set to \u201cFalse\u201d) will define the behavior.<\/font><\/font><\/p>\n

To set these properties you can use the \u201cFramework and References\u201d tab in the property page of the parent project (Project A<\/span><\/b>) as follows:<\/font><\/p>\n

 <\/font><\/p>\n

<\/font><\/p>\n

<\/font><\/span><\/p>\n

<\/font><\/span><\/p>\n

 <\/font><\/p>\n

<\/font><\/p>\n

 <\/font><\/p>\n

<\/p>\n

It looks like the following in Project A.vcxproj:<\/font><\/p>\n

<<\/span>ItemGroup<\/span>><\/span><\/span><\/p>\n

    <\/span><<\/span>ProjectReference<\/span> <\/span>Include<\/span>=<\/span>“..\\Project B\\Project B.vcxproj<\/span>“><\/span><\/span><\/p>\n

      <\/span><<\/span>Project<\/span>><\/span>{fcefddd7-fc28-490a-a937-ee8ce39c43d7}<\/<\/span>Project<\/span>><\/span><\/span><\/p>\n

      <\/span><<\/span>Private<\/span>><\/span>true<\/<\/span>Private<\/span>><\/span><\/span><\/p>\n

      <\/span><<\/span>ReferenceOutputAssembly<\/span>><\/span>true<\/<\/span>ReferenceOutputAssembly<\/span>><\/span><\/span><\/p>\n

      <\/span><<\/span>CopyLocalSatelliteAssemblies<\/span>><\/span>false<\/<\/span>CopyLocalSatelliteAssemblies<\/span>><\/span><\/span><\/p>\n

      <\/span><<\/span><\/span>LinkLibraryDependencies<\/span>><\/span>false<\/<\/span>LinkLibraryDependencies<\/span>><\/span><\/span><\/p>\n

      <\/span><<\/span>UseLibraryDependencyInputs<\/span>><\/span>false<\/<\/span>UseLibraryDependencyInputs<\/span>><\/span><\/span><\/span><\/p>\n

    <\/span><\/<\/span>ProjectReference<\/span>><\/span><\/span><\/p>\n

    <\/span><<\/span>ProjectReference<\/span> <\/span>Include<\/span>=<\/span>“..\\Project C\\Project C.vcxproj<\/span>“><\/span><\/span><\/p>\n

      <\/span><<\/span>Project<\/span>><\/span>{687d125d-f004-4901-8654-725f65c93528}<\/<\/span>Project<\/span>><\/span><\/span><\/p>\n

    <\/span><\/<\/span>ProjectReference<\/span>><\/span><\/span><\/p>\n

<\/<\/span>ItemGroup<\/span>><\/span><\/p>\n

<\/span> <\/font><\/span><\/p>\n

<\/p>\n

This results in the following command-line for <\/span>Project A<\/span><\/b>:<\/span><\/font><\/p>\n

<\/span><\/font><\/p>\n

<\/span><\/font> <\/span><\/font><\/span><\/p>\n

<\/font><\/span><\/p>\n

Similarly for Project D<\/span><\/b>:<\/font><\/p>\n

 <\/font><\/p>\n

<\/font><\/p>\n

 <\/font><\/p>\n

It looks like the following in Project D.vcxproj:<\/font><\/p>\n

<\/font><\/p>\n

<\/font><\/span><\/p>\n

  <\/span><<\/span>ItemGroup<\/span>><\/span><\/span><\/p>\n

    <\/span><<\/span>ProjectReference<\/span> <\/span>Include<\/span>=<\/span>“..\\Project B\\Project B.vcxproj<\/span>“><\/span><\/span><\/p>\n

      <\/span><<\/span>Project<\/span>><\/span>{fcefddd7-fc28-490a-a937-ee8ce39c43d7}<\/<\/span>Project<\/span>><\/span><\/span><\/p>\n

    <\/span><\/<\/span>ProjectReference<\/span>><\/span><\/p>\n

    <\/span><<\/span>ProjectReference<\/span> <\/span>Include<\/span>=<\/span>“..\\Project C\\Project C.vcxproj<\/span>“><\/span><\/span><\/p>\n

      <\/span><<\/span>Project<\/span>><\/span>{687d125d-f004-4901-8654-725f65c93528}<\/<\/span>Project<\/span>><\/span><\/span><\/p>\n

    <\/span><\/<\/span>ProjectReference<\/span>><\/span><\/span><\/p>\n

  <\/span><\/<\/span>ItemGroup<\/span>><\/span><\/p>\n

<\/span> <\/p>\n

<\/p>\n

This results in the following command-line for <\/font><\/span>Project D<\/span><\/b>:<\/font><\/span><\/font><\/font><\/span><\/p>\n

 <\/p>\n

<\/span> <\/p>\n

 <\/span><\/p>\n

<\/span><\/span><\/p>\n

Thanks,<\/font><\/p>\n

Amit Mohindra<\/font><\/p>\n","protected":false},"excerpt":{"rendered":"

My name is Amit Mohindra and I am a Program Manager with the Visual C++ IDE team. In this post I would like to talk about project-to-project references. In VS2010 release we moved the C++ build and project system to be based on MSBuild. There is an excellent article written by Marian Luparu detailing the […]<\/p>\n","protected":false},"author":289,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-3883","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"

My name is Amit Mohindra and I am a Program Manager with the Visual C++ IDE team. In this post I would like to talk about project-to-project references. In VS2010 release we moved the C++ build and project system to be based on MSBuild. There is an excellent article written by Marian Luparu detailing the […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/3883","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/289"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=3883"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/3883\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=3883"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=3883"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=3883"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}