commit 8e00d6ac269e87705141f817f619d82cf45b6e24 · pyrox.dev/nixpkgs

+2 -2

doc/languages-frameworks/dotnet.section.md

···

71
71

72
72

To package Dotnet applications, you can use `buildDotnetModule`. This has similar arguments to `stdenv.mkDerivation`, with the following additions:

73
73

74
74
-
* `projectFile` is used for specifying the dotnet project file relative to the source root. These usually have `.sln` or `.csproj` file extensions. This can be an array of multiple projects as well.

74
74
+
* `projectFile` is used for specifying the dotnet project file, relative to the source root. These usually have `.sln` or `.csproj` file extensions. This can be a list of multiple projects as well. Most of the time dotnet can figure this location out by itself, so this should only be set if necessary.

75
75

* `nugetDeps` takes either a path to a `deps.nix` file, or a derivation. The `deps.nix` file can be generated using the script attached to `passthru.fetch-deps`. This file can also be generated manually using `nuget-to-nix` tool, which is available in nixpkgs. If the argument is a derivation, it will be used directly and assume it has the same output as `mkNugetDeps`.

76
76

* `packNupkg` is used to pack project as a `nupkg`, and installs it to `$out/share`. If set to `true`, the derivation can be used as a dependency for another dotnet project by adding it to `projectReferences`.

77
77

* `projectReferences` can be used to resolve `ProjectReference` project items. Referenced projects can be packed with `buildDotnetModule` by setting the `packNupkg = true` attribute and passing a list of derivations to `projectReferences`. Since we are sharing referenced projects as NuGets they must be added to csproj/fsproj files as `PackageReference` as well.

···

100
100

* `dotnetPackFlags` can be used to pass flags to `dotnet pack`. Used only if `packNupkg` is set to `true`.

101
101

* `dotnetFlags` can be used to pass flags to all of the above phases.

102
102

103
103
-
When packaging a new application, you need to fetch it's dependencies. You can set `nugetDeps` to an empty string to make the derivation temporarily evaluate, and then run `nix-build -A package.passthru.fetch-deps` to generate it's dependency fetching script. After running the script, you should have the location of the generated lockfile printed to the console. This can be copied to a stable directory. Note that if either `projectFile` or `nugetDeps` are unset, this script cannot be generated!

103
103
+
When packaging a new application, you need to fetch its dependencies. You can run `nix-build -A package.fetch-deps` to generate a script that will build a lockfile for you. After running the script you should have the location of the generated lockfile printed to the console, which can be copied to a stable directory. Then set `nugetDeps = ./deps.nix` and you're ready to build the derivation.

104
104

105
105

Here is an example `default.nix`, using some of the previously discussed arguments:

106
106

```nix

+10 -12

pkgs/build-support/dotnet/build-dotnet-module/default.nix

···

       82
       82
        
       , ...

     

       83
       83
        
       } @ args:

     

       84
       84
        
       

     

       85
       85
       -
       # TODO: Automatically generate a dependency file when a lockfile is present.

     

       86
       86
       -
       # This file is unfortunately almost never present, as Microsoft recommands not to push this in upstream repositories.

     

       87
       87
       -
       assert nugetDeps == null -> throw "Defining the `nugetDeps` attribute is required, as to lock the NuGet dependencies. This file can be generated by running the `passthru.fetch-deps` script.";

     

       88
       88
       -
       

     

       89
       85
        
       let

     

       90
       86
        
         inherit (callPackage ./hooks {

     

       91
       87
        
           inherit dotnet-sdk dotnet-test-sdk disabledTests nuget-source dotnet-runtime runtimeDeps buildType;

     
···

       97
       93
        
           else null;

     

       98
       94
        
       

     

       99
       95
        
         _nugetDeps =

     

       100
       100
       -
           if lib.isDerivation nugetDeps

     

       101
       101
       -
           then nugetDeps

     

       102
       102
       -
           else mkNugetDeps { inherit name; nugetDeps = import nugetDeps; };

     

       96
       96
       +
           if (nugetDeps != null) then

     

       97
       97
       +
             if lib.isDerivation nugetDeps

     

       98
       98
       +
             then nugetDeps

     

       99
       99
       +
             else mkNugetDeps { inherit name; nugetDeps = import nugetDeps; }

     

       100
       100
       +
           else throw "Defining the `nugetDeps` attribute is required, as to lock the NuGet dependencies. This file can be generated by running the `passthru.fetch-deps` script.";

     

       103
       101
        
       

     

       104
       102
        
         # contains the actual package dependencies

     

       105
       105
       -
         _dependenciesSource = mkNugetSource {

     

       103
       103
       +
         dependenciesSource = mkNugetSource {

     

       106
       104
        
           name = "${name}-dependencies-source";

     

       107
       105
        
           description = "A Nuget source with the dependencies for ${name}";

     

       108
       106
        
           deps = [ _nugetDeps ] ++ lib.optional (localDeps != null) localDeps;

     
···

       111
       109
        
         # this contains all the nuget packages that are implictly referenced by the dotnet

     

       112
       110
        
         # build system. having them as separate deps allows us to avoid having to regenerate

     

       113
       111
        
         # a packages dependencies when the dotnet-sdk version changes

     

       114
       114
       -
         _sdkDeps = mkNugetDeps {

     

       112
       112
       +
         sdkDeps = mkNugetDeps {

     

       115
       113
        
           name = "dotnet-sdk-${dotnet-sdk.version}-deps";

     

       116
       114
        
           nugetDeps = dotnet-sdk.passthru.packages;

     

       117
       115
        
         };

     

       118
       116
        
       

     

       119
       119
       -
         _sdkSource = mkNugetSource {

     

       117
       117
       +
         sdkSource = mkNugetSource {

     

       120
       118
        
           name = "dotnet-sdk-${dotnet-sdk.version}-source";

     

       121
       121
       -
           deps = [ _sdkDeps ];

     

       119
       119
       +
           deps = [ sdkDeps ];

     

       122
       120
        
         };

     

       123
       121
        
       

     

       124
       122
        
         nuget-source = symlinkJoin {

     

       125
       123
        
           name = "${name}-nuget-source";

     

       126
       126
       -
           paths = [ _dependenciesSource _sdkSource ];

     

       124
       124
       +
           paths = [ dependenciesSource sdkSource ];

     

       127
       125
        
         };

     

       128
       126
        
       in

     

       129
       127
        
       stdenvNoCC.mkDerivation (args // {