How to create a nuget package which copies files to the build output of the consumer

Question

There is tons of material online about creating nuget packages, however, there seem to be also tons of options (dotnet pack, nuget.exe pack, msbuild t:pack etc.). I tried several suggestions from the official docs, but all I can manage is copying *.dll's to the binary output folder of the consuming project. I struggle, because most I find online does not mention whether the documentation talks about the current nuget package output folder, or the consumer. This distinction makes all the difference for me.

Here is what I want

• I have three files: some.dll, some.tlb and some.txt. to be included in myNuGetPackage.nupkg
• I want all of them to be copied to the binary output folder of the consuming solution/csproj when msbuild runs for the consuming csproj
• Use <PackageReference> in the consuming csproj
• I don't necessarily want to build a myNuGetPackage.csproj, because I am not creating anything. I have these files and want to zip them. If there is no other option, than creating a myNuGetPackage.csproj, I would do it.
• I want the solution as easy as possible. I would prefer to open a tool like the "nuget package explorer", add my three files, but I think that's impossible?
• I don't think it matters, but I want to target .NETFramework 4.8

Here is what I have tried and failed:

• I have only tried creating my own my.nuspec with nuget.exe pack my.nuspec
• copyToOutput from contentFiles see here

Here is my exact content of myPackage.nuspec

<?xml version="1.0"?>
<package >
  <metadata>
    <id>myPackage</id>
    <version>1.0.0</version>
    <authors>me</authors>
    <requireLicenseAcceptance>false</requireLicenseAcceptance>
    <description>bla bla</description>
    <dependencies>
      <group targetFramework=".NETFramework4.8.0" />
    </dependencies>
        <contentFiles>
            <files include="**/*.tlb" buildAction="None" copyToOutput="true" flatten="true" />
            <files include="any/any/*.txt" buildAction="Compile" copyToOutput="true" flatten="true"/>
            <files include="any/any/*.xml" buildAction="EmbeddedResource" copyToOutput="true" flatten="true"/>
        </contentFiles>
  </metadata>
</package>

My file structure is

lib\net48\my.dll --> Gets copied to build output of the consumer

content\any\any\my.tlb content\any\any\my.xml content\any\any\my.txt --> None of these gets copied to build output of the consumer.

I noticed that all my files are included in the .nupkg and all of them are extracted to <users>\packages\myPackage\1.0.0\content\any\any regardless if I set copyToOutput to true or false. That tells me, that copyToOutput should actually copy files to the consuming build folder. Why is it not working in my case?

Answer 1

I will try to split this up best I can. I have created a sample project to follow along to here as well if you'd like (https://github.com/BenjaminMichaelis/Samples/tree/main/CopyFilesInNugetPackage). To generate the .nupkg all you have to do is run dotnet pack -o . in the root directory.

First off in your .csproj for your nuget project. First line is special for the schema to tell it to do nothing when you build. The PropertyGroup is just some standard settings.

Getting to the interesting stuff, in the ItemGroup, we declare first the Include= which points to the relative path of the items we want to grab, using a globbing pattern. In my sample repo, you see that there is a file3.json in the TestFiles/Folder1, this does not get picked up because it only searches in TestFiles. However, the file2.html in TestFiles/Folder1 does get picked up because of the ** globing pattern beforehand telling it to search recursively. The same logic applies for the markdown and the .targets file. You can use this logic to include any files you want into your nuget package. The .targets file is essential for automatically copying into your target project. You can change these values to get the files you want from inside bin or wherever.

Then the PackagePath= points to the directory we want this stored under in the package itself.

In the end after packing the project using dotnet pack -o . I can use the https://github.com/NuGetPackageExplorer/NuGetPackageExplorer to easily inspect the .nupkg file to see inside of my package and make sure everything is there like I expect. (I have included the nupkg I generated in the repo as well if you don't want to make one).

CopyFilesNuget.csproj :

<Project Sdk="Microsoft.Build.NoTargets/3.7.0">
  <PropertyGroup>
    <TargetFramework>net7.0</TargetFramework>
    <NoWarn>NU5128</NoWarn>
    <IsPackable>true</IsPackable>
    <VersionPrefix>1.1.0</VersionPrefix>
  </PropertyGroup>

  <ItemGroup>
    <None Include="TestFiles/*.json" Pack="true" PackagePath="TestFiles" />
    <None Include="TestFiles/**/*.html" Pack="true" PackagePath="TestFiles" />
    <None Include="Markdown/*.md" Pack="true" PackagePath="Markdown" />
    <None Include="Build/CopyFilesNuget.targets" Pack="true" PackagePath="build\CopyFilesNuget.targets"/>
  </ItemGroup>

</Project>

Lastly, to copy out the resulting files, in a MyProjectName.targets file (the .targets extension is important looking at https://learn.microsoft.com/visualstudio/msbuild/customize-your-build?view=vs-2019&WT.mc_id=8B97120A00B57354#import-order) you can do something like:

CopyFilesNuget.targets :

<Project>
  <ItemGroup>
    <TestFilesFilesToCopy Include="$(MSBuildThisFileDirectory)../TestFiles/**/*.*"/>
    <MarkdownFilesToCopy Include="$(MSBuildThisFileDirectory)../Markdown/*.*"/>
  </ItemGroup>
  <Target Name="CopyContent" BeforeTargets="Build">
    <Copy SourceFiles="@(TestFilesFilesToCopy)" DestinationFolder="$(ProjectDir)TestFiles/%(RecursiveDir)" SkipUnchangedFiles="true" />
    <Copy SourceFiles="@(MarkdownFilesToCopy)" DestinationFolder="$(ProjectDir)Markdown/%(RecursiveDir)" SkipUnchangedFiles="true" />
  </Target>
</Project>

Here, in the first ItemGroup we set the paths to the directories we want to copy out from in the nuget package (we set these in our csproj as the destination within our package) and then that gets passed into the Copy task within the Target as the SourceFiles variable. Where those get copied to is the DestinationFolder value.

An important part here is that the <Target> tag is used. This automatically gets used by the consuming project and the BeforeTargets tells it where in the msbuild order to run (in this case before the Build).

With this nupkg file you can consume this in your other project however you'd normally do so (from nuget.org, locally, a private nuget feed, etc.)

If there are any questions just let me know!

Answer 2

I managed to find a simple solution

1. Create the following exact file structure

.\myPackage\lib\net48\my.xml
.\myPackage\lib\net48\my.dll
.\myPackage\contentFiles\any\any\my.tlb

2. Create a myPackage.nuspec file like this

<metadata>
 <id>myPackage</id>
 <version>1.2.3</version>
 ...
<dependencies>
  <group targetFramework=".NETFramework4.8.0" />
</dependencies>
 <contentFiles>
    <files include="**\*.tlb" buildAction="Content" copyToOutput="true" flatten="true" />
</contentFiles>
</metadata>

3. Use nuget pack myPackage.nuspec and done! That's all you have to do.

Further notes: I realized when I change the file structure, to e.g.

.\myPackage\content\any\any\my.tlb

I have to include all files manually in the .nuspec and map content to contentFiles

</metadata>  
<files>
      <file src="content\any\any\my.tlb" target="contentFiles\any\any\my.tlb"></file>
      <file src="lib\net48\my.dll" target="lib\net48"></file>
      <file src="lib\net48\my.XML" target="lib\net48"></file>
</files>

So make sure to name the folder exactly contentFiles!