Informazioni di riferimento sul file .nuspec.nuspec reference

Un file .nuspec è un manifesto XML che contiene i metadati del pacchetto.A .nuspec file is an XML manifest that contains package metadata. Questo manifesto viene usato per compilare il pacchetto e per fornire informazioni ai consumer.This manifest is used both to build the package and to provide information to consumers. Il manifesto viene sempre incluso in un pacchetto.The manifest is always included in a package.

In questo argomentoIn this topic:

Compatibilità del tipo di progettoProject type compatibility

Formato generale e schemaGeneral form and schema

Il file dello schema di nuspec.xsd corrente è disponibile nel repository GitHub di NuGet.The current nuspec.xsd schema file can be found in the NuGet GitHub repository.

All'interno di questo schema, un file .nuspec ha il formato generale seguente:Within this schema, a .nuspec file has the following general form:

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        <!-- Required elements-->
        <id></id>
        <version></version>
        <description></description>
        <authors></authors>

        <!-- Optional elements -->
        <!-- ... -->
    </metadata>
    <!-- Optional 'files' node -->
</package>

Per una rappresentazione visiva chiara dello schema, aprire il file di schema in Visual Studio in modalità progettazione e fare clic sul collegamento XML Schema Explorer.For a clear visual representation of the schema, open the schema file in Visual Studio in Design mode and click on the XML Schema Explorer link. In alternativa, aprire il file come codice, fare clic con il pulsante destro del mouse nell'editor e scegliere Mostra in XML Schema Explorer.Alternately, open the file as code, right-click in the editor, and select Show XML Schema Explorer. In entrambi i casi si ottiene una visualizzazione simile alla seguente (quando è per la maggior parte espansa):Either way you get a view like the one below (when mostly expanded):

Visual Studio Schema Explorer con nuspec.xsd aperto

Elementi dei metadati obbligatoriRequired metadata elements

Anche se gli elementi seguenti sono i requisiti minimi per un pacchetto, è consigliabile aggiungere gli elementi dei metadati facoltativi per migliorare l'esperienza complessiva degli sviluppatori con il pacchetto.Although the following elements are the minimum requirements for a package, you should consider adding the optional metadata elements to improve the overall experience developers have with your package.

Questi elementi devono essere visualizzati all'interno di un elemento <metadata>.These elements must appear within a <metadata> element.

idid

Identificatore del pacchetto senza distinzione tra maiuscole e minuscole che deve essere univoco in nuget.org o in qualsiasi raccolta in cui risiede il pacchetto.The case-insensitive package identifier, which must be unique across nuget.org or whatever gallery the package resides in. L'ID non può contenere spazi o caratteri non validi per un URL e in genere segue le regole dello spazio dei nomi .NET.IDs may not contain spaces or characters that are not valid for a URL, and generally follow .NET namespace rules. Vedere Choosing a unique package identifier and setting the version number (Scelta di un identificatore univoco del pacchetto e impostazione del numero di versione) per altre indicazioni.See Choosing a unique package identifier for guidance.

versionversion

La versione del pacchetto secondo il criterio principale.secondaria.patch.The version of the package, following the major.minor.patch pattern. I numeri di versione possono includere un suffisso di versione non definitiva, come descritto in Controllo delle versioni dei pacchetti.Version numbers may include a pre-release suffix as described in Package versioning.

descriptiondescription

Descrizione del pacchetto per la visualizzazione dell'interfaccia utente.A description of the package for UI display.

authorsauthors

Elenco con valori delimitati da virgola di autori di pacchetti, corrispondenti ai nomi di profili in nuget.org. Questi, visualizzati nella raccolta NuGet in nuget.org, vengono usati per creare riferimenti incrociati ai pacchetti dello stesso autore.A comma-separated list of packages authors, matching the profile names on nuget.org. These are displayed in the NuGet Gallery on nuget.org and are used to cross-reference packages by the same authors.

Elementi dei metadati facoltativiOptional metadata elements

ownersowners

Elenco con valori delimitati da virgola di autori di pacchetti, corrispondenti ai nomi di profili in nuget.org. Si tratta spesso dello stesso elenco in authors e viene ignorato durante il caricamento del pacchetto in nuget.org. Vedere Gestione dei proprietari dei pacchetti in nuget.org.A comma-separated list of the package creators using profile names on nuget.org. This is often the same list as in authors, and is ignored when uploading the package to nuget.org. See Managing package owners on nuget.org.

projectUrlprojectUrl

URL della pagina iniziale del pacchetto, spesso visualizzato nell'interfaccia utente e in nuget.org.A URL for the package's home page, often shown in UI displays as well as nuget.org.

licenseUrllicenseUrl

Importante

licenseUrl è deprecato.licenseUrl is deprecated. Usare invece la licenza.Use license instead.

URL per la licenza del pacchetto, spesso visualizzato in interfacce utente come nuget.org.A URL for the package's license, often shown in UIs like nuget.org.

licenzalicense

Espressione di licenza SPDX o percorso di un file di licenza all'interno del pacchetto, spesso visualizzato in interfacce utente come nuget.org. Se si sta eseguendo la licenza del pacchetto con una licenza comune, ad esempio MIT o BSD-2-clause, usare l' identificatore di licenza SPDXassociato.An SPDX license expression or path to a license file within the package, often shown in UIs like nuget.org. If you're licensing the package under a common license, like MIT or BSD-2-Clause, use the associated SPDX license identifier. Ad esempio:For example:

<license type="expression">MIT</license>

Nota

NuGet.org accetta solo le espressioni di licenza approvate dall'iniziativa Open Source o dalla versione gratuita di Software Foundation.NuGet.org only accepts license expressions that are approved by the Open Source Initiative or the Free Software Foundation.

Se il pacchetto è concesso in licenza in base a più licenze comuni, è possibile specificare una licenza composita usando la sintassi dell'espressione SPDX versione 2,0.If your package is licensed under multiple common licenses, you can specify a composite license using the SPDX expression syntax version 2.0. Ad esempio:For example:

<license type="expression">BSD-2-Clause OR MIT</license>

Se si usa una licenza personalizzata che non è supportata dalle espressioni di licenza, è possibile .txt creare .md un pacchetto di un file o con il testo della licenza.If you use a custom license that isn't supported by license expressions, you can package a .txt or .md file with the license's text. Ad esempio:For example:

<package>
  <metadata>
    ...
    <license type="file">LICENSE.txt</license>
    ...
  </metadata>
  <files>
    ...
    <file src="licenses\LICENSE.txt" target="" />
    ...
  </files>
</package>

Per l'equivalente MSBuild, vedere la pagina relativa all' imballaggio di un'espressione di licenza o di un file di licenza.For the MSBuild equivalent, take a look at Packing a license expression or a license file.

La sintassi esatta delle espressioni di licenza di NuGet è descritta di seguito in ABNF.The exact syntax of NuGet's license expressions is described below in ABNF.

license-id            = <short form license identifier from https://spdx.org/spdx-specification-21-web-version#h.luq9dgcle9mo>

license-exception-id  = <short form license exception identifier from https://spdx.org/spdx-specification-21-web-version#h.ruv3yl8g6czd>

simple-expression = license-id / license-id”+”

compound-expression =  1*1(simple-expression /
                simple-expression "WITH" license-exception-id /
                compound-expression "AND" compound-expression /
                compound-expression "OR" compound-expression ) /                
                "(" compound-expression ")" )

license-expression =  1*1(simple-expression / compound-expression / UNLICENSED)

iconUrliconUrl

Importante

iconUrl è deprecato.iconUrl is deprecated. Usare invece l'icona.Use icon instead.

URL di un'immagine 64x64 con sfondo trasparente da usare come icona per il pacchetto nella visualizzazione dell'interfaccia utente.A URL for a 64x64 image with transparency background to use as the icon for the package in UI display. Assicurarsi che questo elemento contenga l'URL diretto dell'immagine e non l'URL di una pagina Web contenente l'immagine.Be sure this element contains the direct image URL and not the URL of a web page containing the image. Ad esempio, per usare un'immagine da GitHub, usare l'URL del file non https://github.com/<username>/<repository>/raw/<branch>/<logo.png>elaborato come.For example, to use an image from GitHub, use the raw file URL like https://github.com/<username>/<repository>/raw/<branch>/<logo.png>.

iconaicon

Si tratta di un percorso di un file di immagine all'interno del pacchetto, spesso visualizzato in interfacce utente come nuget.org come icona del pacchetto.It is a path to an image file within the package, often shown in UIs like nuget.org as the package icon. Le dimensioni del file di immagine sono limitate a 1 MB.Image file size is limited to 1 MB. I formati di file supportati sono JPEG e PNG.Supported file formats include JPEG and PNG. Si consiglia un'immagine Resoulution di 64x64.We recommend an image resoulution of 64x64.

Ad esempio, quando si crea un pacchetto con NuGet. exe, è necessario aggiungere il codice seguente al NuSpec:For example, you would add the following to your nuspec when creating a package using nuget.exe:

<package>
  <metadata>
    ...
    <icon>images\icon.png</icon>
    ...
  </metadata>
  <files>
    ...
    <file src="..\icon.png" target="images\" />
    ...
  </files>
</package>

Esempio di icona del pacchetto NuSpec.Package Icon nuspec sample.

Per l'equivalente MSBuild, vedere la pagina relativa all'imballaggio di un file di immagine icona.For the MSBuild equivalent, take a look at Packing an icon image file.

requireLicenseAcceptancerequireLicenseAcceptance

Valore booleano che specifica se il client deve richiedere al consumer di accettare la licenza del pacchetto prima di installarlo.A Boolean value specifying whether the client must prompt the consumer to accept the package license before installing the package.

developmentDependencydevelopmentDependency

(2.8 +) Valore booleano che specifica se il pacchetto deve essere contrassegnato come dipendenza solo per lo sviluppo, in modo che il pacchetto non possa essere incluso come dipendenza in altri pacchetti.(2.8+) A Boolean value specifying whether the package is be marked as a development-only-dependency, which prevents the package from being included as a dependency in other packages. Con PackageReference (NuGet 4.8 +), questo flag indica anche che gli asset in fase di compilazione vengono esclusi dalla compilazione.With PackageReference (NuGet 4.8+), this flag also means that it will exclude compile-time assets from compilation. Vedere supporto di DevelopmentDependency per PackageReferenceSee DevelopmentDependency support for PackageReference

summarysummary

Importante

summaryverrà deprecato.summary is being deprecated. In alternativa, utilizzare description.Use description instead.

Descrizione breve del pacchetto per la visualizzazione dell'interfaccia utente.A short description of the package for UI display. Se omesso, viene usata una versione troncata di description.If omitted, a truncated version of description is used.

releaseNotesreleaseNotes

(1.5+) Descrizione delle modifiche apportate in questa versione del pacchetto, spesso usata nell'interfaccia utente, come la scheda Aggiornamenti di Gestione pacchetti di Visual Studio, in sostituzione della descrizione del pacchetto.(1.5+) A description of the changes made in this release of the package, often used in UI like the Updates tab of the Visual Studio Package Manager in place of the package description.

(1.5+) Informazioni sul copyright per il pacchetto.(1.5+) Copyright details for the package.

languagelanguage

ID delle impostazioni locali per il pacchetto.The locale ID for the package. Vedere Creazione di pacchetti localizzati.See Creating localized packages.

tagstags

Elenco di tag e parole chiave delimitati da spazi che descrivono il pacchetto e facilitano l'individuabilità dei pacchetti tramite meccanismi di ricerca e filtro.A space-delimited list of tags and keywords that describe the package and aid discoverability of packages through search and filtering.

utileserviceable

(3.3+) Solo per uso interno in NuGet.(3.3+) For internal NuGet use only.

repositoryrepository

Metadati del repository, composti da quattro attributi facoltativi type : url and branch (4.0 +) , and commit e (4.6 +) .Repository metadata, consisting of four optional attributes: type and url (4.0+), and branch and commit (4.6+). Questi attributi consentono di eseguire il .nupkg mapping di al repository che lo ha compilato, con la possibilità di ottenere informazioni dettagliate come il nome del singolo ramo e/o l'hash SHA-1 di commit che ha compilato il pacchetto.These attributes allow you to map the .nupkg to the repository that built it, with the potential to get as detailed as the individual branch name and / or commit SHA-1 hash that built the package. Deve trattarsi di un URL disponibile pubblicamente che può essere richiamato direttamente da un software di controllo della versione.This should be a publicly available url that can be invoked directly by a version control software. Non deve trattarsi di una pagina HTML, perché è destinata al computer.It should not be an html page as this is meant for the computer. Per il collegamento alla pagina del progetto, usare projectUrl invece il campo.For linking to project page, use the projectUrl field, instead.

Ad esempio:For example:

<?xml version="1.0"?>
<package xmlns="http://schemas.microsoft.com/packaging/2016/06/nuspec.xsd">
    <metadata>
        ...
        <repository type="git" url="https://github.com/NuGet/NuGet.Client.git" branch="dev" commit="e1c65e4524cd70ee6e22abe33e6cb6ec73938cb3" />
        ...
    </metadata>
</package>

titletitle

Titolo descrittivo del pacchetto che può essere usato in alcune visualizzazioni dell'interfaccia utente.A human-friendly title of the package which may be used in some UI displays. (nuget.org e gestione pacchetti in Visual Studio non mostrano titolo)(nuget.org and the Package Manager in Visual Studio do not show title)

Elementi di raccoltaCollection elements

packageTypespackageTypes

(3.5 +) Raccolta di zero o più elementi <packageType> che specificano il tipo del pacchetto se diverso da un pacchetto di dipendenza tradizionale.(3.5+) A collection of zero or more <packageType> elements specifying the type of the package if other than a traditional dependency package. Ogni packageType include gli attributi di name e version.Each packageType has attributes of name and version. Vedere Setting a package type (Impostazione di un tipo di pacchetto).See Setting a package type.

dipendenzedependencies

Raccolta di zero o più elementi <dependency> che specificano le dipendenze per il pacchetto.A collection of zero or more <dependency> elements specifying the dependencies for the package. Ogni dipendenza include gli attributi id, version, include (3.x+) ed exclude (3.x+).Each dependency has attributes of id, version, include (3.x+), and exclude (3.x+). Vedere Dipendenze di seguito.See Dependencies below.

frameworkAssembliesframeworkAssemblies

(1.2 +) Raccolta di zero o più elementi <frameworkAssembly> che identificano i riferimenti ad assembly .NET Framework richiesti dal pacchetto. Ciò assicura che i riferimenti vengano aggiunti ai progetti che utilizzano il pacchetto.(1.2+) A collection of zero or more <frameworkAssembly> elements identifying .NET Framework assembly references that this package requires, which ensures that references are added to projects consuming the package. Ogni frameworkAssembly include gli attributi assemblyName e targetFramework.Each frameworkAssembly has assemblyName and targetFramework attributes. Vedere Riferimenti agli assembly del framework più avanti.See Specifying framework assembly references GAC below. |

riferimentireferences

(1.5 +) Raccolta di zero o più elementi <reference> per la denominazione degli assembly nella cartella lib del pacchetto, aggiunti come riferimenti al progetto.(1.5+) A collection of zero or more <reference> elements naming assemblies in the package's lib folder that are added as project references. Ogni riferimento include un attributo file.Each reference has a file attribute. <references> può anche contenere un elemento <group> con un attributo targetFramework, che contiene a sua volta elementi <reference>.<references> can also contain a <group> element with a targetFramework attribute, that then contains <reference> elements. Se omesso, vengono inclusi tutti i riferimenti in lib.If omitted, all references in lib are included. Vedere Riferimenti espliciti agli assembly più avanti.See Specifying explicit assembly references below.

contentFilescontentFiles

(3.3 +) Raccolta di elementi <files> che identificano i file di contenuto da includere nel progetto che utilizza il pacchetto.(3.3+) A collection of <files> elements that identify content files to include in the consuming project. Questi file sono specificati con un set di attributi che descrivono come devono essere usati all'interno del sistema del progetto.These files are specified with a set of attributes that describe how they should be used within the project system. Vedere Inclusione di file di assembly più avanti.See Specifying files to include in the package below.

filesfiles

Il <package> nodo può contenere un <files> nodo di <metadata>pari livello e un <contentFiles> elemento figlio in <metadata>per specificare l'assembly e i file di contenuto da includere nel pacchetto.The <package> node may contain a <files> node as a sibling to <metadata>, and a <contentFiles> child under <metadata>, to specify which assembly and content files to include in the package. Vedere Inclusione di file di assembly e Inclusione di file di contenuto più avanti in questo argomento per ulteriori dettagli.See Including assembly files and Including content files later in this topic for details.

attributi di metadatimetadata attributes

minClientVersionminClientVersion

Specifica la versione minima del client NuGet, imposta da nuget.exe e da Gestione pacchetti di Visual Studio, che può installare questo pacchetto.Specifies the minimum version of the NuGet client that can install this package, enforced by nuget.exe and the Visual Studio Package Manager. Questo attributo viene usato ogni volta che il pacchetto dipende da funzionalità specifiche del file .nuspec aggiunte in una particolare versione del client NuGet.This is used whenever the package depends on specific features of the .nuspec file that were added in a particular version of the NuGet client. Ad esempio, un pacchetto che usa l'attributo developmentDependency deve specificare "2.8" per minClientVersion.For example, a package using the developmentDependency attribute should specify "2.8" for minClientVersion. Analogamente, un pacchetto che usa l'elemento contentFiles (vedere la sezione successiva) deve impostare minClientVersion su "3.3".Similarly, a package using the contentFiles element (see the next section) should set minClientVersion to "3.3". Si noti che poiché i client NuGet prima della versione 2.5 non riconoscono questo flag, essi rifiutano sempre di installare il pacchetto indipendentemente dal contenuto di minClientVersion.Note also that because NuGet clients prior to 2.5 do not recognize this flag, they always refuse to install the package no matter what minClientVersion contains.

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2013/01/nuspec.xsd">
    <metadata minClientVersion="100.0.0.1">
        <id>dasdas</id>
        <version>2.0.0</version>
        <title />
        <authors>dsadas</authors>
        <owners />
        <requireLicenseAcceptance>false</requireLicenseAcceptance>
        <description>My package description.</description>
    </metadata>
    <files>
        <file src="content\one.txt" target="content\one.txt" />
    </files>
</package>

Token di sostituzioneReplacement tokens

Quando si crea un pacchetto, il comando nuget pack sostituisce i token delimitati da $ nel nodo <metadata> del file .nuspec con valori provenienti da un file di progetto o dall'opzione -properties del comando pack.When creating a package, the nuget pack command replaces $-delimited tokens in the .nuspec file's <metadata> node with values that come from either a project file or the pack command's -properties switch.

Nella riga di comando, i valori dei token vengono specificati con nuget pack -properties <name>=<value>;<name>=<value>.On the command line, you specify token values with nuget pack -properties <name>=<value>;<name>=<value>. Ad esempio, è possibile usare un token come $owners$ e $desc$ nel file .nuspec e specificare i valori al momento della creazione del pacchetto come indicato di seguito:For example, you can use a token such as $owners$ and $desc$ in the .nuspec and provide the values at packing time as follows:

nuget pack MyProject.csproj -properties
    owners=janedoe,harikm,kimo,xiaop;desc="Awesome app logger utility"

Per usare valori da un progetto, specificare il token descritto nella tabella riportata di seguito (AssemblyInfo fa riferimento al file in Properties, ad esempio AssemblyInfo.cs o AssemblyInfo.vb).To use values from a project, specify the tokens described in the table below (AssemblyInfo refers to the file in Properties such as AssemblyInfo.cs or AssemblyInfo.vb).

Per usare questi token, eseguire nuget pack con il file di progetto anziché semplicemente il file .nuspec.To use these tokens, run nuget pack with the project file rather than just the .nuspec. Ad esempio, quando si usa il comando seguente, i token $id$ e $version$ in un file .nuspec vengono sostituiti con i valori AssemblyName e AssemblyVersion del progetto:For example, when using the following command, the $id$ and $version$ tokens in a .nuspec file are replaced with the project's AssemblyName and AssemblyVersion values:

nuget pack MyProject.csproj

In genere, quando si dispone di un progetto, si crea inizialmente il file .nuspec con nuget spec MyProject.csproj, che include automaticamente alcuni di questi token standard.Typically, when you have a project, you create the .nuspec initially using nuget spec MyProject.csproj which automatically includes some of these standard tokens. Tuttavia, se un progetto non include i valori per elementi .nuspec obbligatori, nuget pack ha esito negativo.However, if a project lacks values for required .nuspec elements, then nuget pack fails. Inoltre, se si modificano i valori del progetto, assicurarsi di ricompilare prima di creare il pacchetto. Questa operazione può essere eseguita facilmente con l'opzione build del comando pack.Furthermore, if you change project values, be sure to rebuild before creating the package; this can be done conveniently with the pack command's build switch.

Ad eccezione di $configuration$, i valori nel progetto vengono usati preferenzialmente rispetto a qualsiasi altro valore assegnato allo stesso token nella riga di comando.With the exception of $configuration$, values in the project are used in preference to any assigned to the same token on the command line.

TokenToken Origine del valoreValue source ValueValue
$id$$id$ File di progettoProject file AssemblyName (title) dal file di progettoAssemblyName (title) from the project file
$version$$version$ AssemblyInfoAssemblyInfo AssemblyInformationalVersion se presente, in caso contrario AssemblyVersionAssemblyInformationalVersion if present, otherwise AssemblyVersion
$author$$author$ AssemblyInfoAssemblyInfo AssemblyCompanyAssemblyCompany
$title$$title$ AssemblyInfoAssemblyInfo AssemblyTitleAssemblyTitle
$description$$description$ AssemblyInfoAssemblyInfo AssemblyDescriptionAssemblyDescription
$copyright$$copyright$ AssemblyInfoAssemblyInfo AssemblyCopyrightAssemblyCopyright
$configuration$$configuration$ DLL dell'assemblyAssembly DLL Configurazione usata per compilare l'assembly, con impostazione predefinita Debug.Configuration used to build the assembly, defaulting to Debug. Si noti che per creare un pacchetto con la configurazione Rilascio, è sempre necessario usare -properties Configuration=Release nella riga di comando.Note that to create a package using a Release configuration, you always use -properties Configuration=Release on the command line.

I token possono essere usati anche per risolvere i percorsi quando si includono file di assembly e file di contenuto.Tokens can also be used to resolve paths when you include assembly files and content files. I token hanno gli stessi nomi delle proprietà di MSBuild e ciò consente di selezionare i file da includere a seconda della configurazione di compilazione corrente.The tokens have the same names as the MSBuild properties, making it possible to select files to be included depending on the current build configuration. Ad esempio, se si usano i token seguenti nel file .nuspec:For example, if you use the following tokens in the .nuspec file:

<files>
    <file src="bin\$configuration$\$id$.pdb" target="lib\net40" />
</files>

E si compila un assembly il cui AssemblyName è LoggingLibrary con la configurazione Release in MSBuild, le righe risultanti nel file .nuspec nel pacchetto sono le seguenti:And you build an assembly whose AssemblyName is LoggingLibrary with the Release configuration in MSBuild, the resulting lines in the .nuspec file in the package is as follows:

<files>
    <file src="bin\Release\LoggingLibrary.pdb" target="lib\net40" />
</files>

Elemento dipendenzeDependencies element

L'elemento <dependencies> all'interno di <metadata> contiene qualsiasi numero di elementi <dependency> che identificano altri pacchetti da cui dipende il pacchetto di livello superiore.The <dependencies> element within <metadata> contains any number of <dependency> elements that identify other packages upon which the top-level package depends. Gli attributi per ogni <dependency> sono i seguenti:The attributes for each <dependency> are as follows:

AttributoAttribute DescrizioneDescription
id (Obbligatorio) ID pacchetto della dipendenza, ad esempio "EntityFramework" e "NUnit", ovvero il nome di pacchetto che nuget.org mostra nella pagina di un pacchetto.(Required) The package ID of the dependency, such as "EntityFramework" and "NUnit", which is the name of the package nuget.org shows on a package page.
version (Obbligatorio) Intervallo di versioni accettabili come dipendenza.(Required) The range of versions acceptable as a dependency. Per la sintassi esatta, vedere Controllo delle versioni dei pacchetti.See Package versioning for exact syntax. Le versioni con caratteri jolly (mobili) non sono supportate.Wildcard (floating) versions are not supported.
includeinclude Elenco delimitato da virgole di tag di inclusione/esclusione (vedere di seguito) che indicano la dipendenza da includere nel pacchetto finale.A comma-delimited list of include/exclude tags (see below) indicating of the dependency to include in the final package. Il valore predefinito è all.The default value is all.
excludeexclude Elenco delimitato da virgole di tag di inclusione/esclusione (vedere di seguito) che indicano la dipendenza da escludere nel pacchetto finale.A comma-delimited list of include/exclude tags (see below) indicating of the dependency to exclude in the final package. Il valore predefinito è build,analyzers , che può essere sovrascritto.The default value is build,analyzers which can be over-written. Ma content/ ContentFiles sono esclusi anche in modo implicito nel pacchetto finale che non può essere sovrascritto.But content/ ContentFiles are also implicitly excluded in the final package which can't be over-written. I tag specificati con exclude hanno la precedenza rispetto a quelli specificati con include.Tags specified with exclude take precedence over those specified with include. Ad esempio, include="runtime, compile" exclude="compile" equivale a include="runtime".For example, include="runtime, compile" exclude="compile" is the same as include="runtime".
Tag di inclusione/esclusioneInclude/Exclude tag Cartelle di destinazione interessateAffected folders of the target
contentFilescontentFiles ContentContent
runtimeruntime Runtime, Resources e FrameworkAssembliesRuntime, Resources, and FrameworkAssemblies
compilecompile liblib
buildbuild build (proprietà e destinazioni MSBuild)build (MSBuild props and targets)
nativinative nativinative
nonenone Nessuna cartellaNo folders
tuttiall Tutte le cartelleAll folders

Ad esempio, le righe seguenti indicano dipendenze da PackageA versione 1.1.0 o successive e da PackageB versione 1.x.For example, the following lines indicate dependencies on PackageA version 1.1.0 or higher, and PackageB version 1.x.

<dependencies>
    <dependency id="PackageA" version="1.1.0" />
    <dependency id="PackageB" version="[1,2)" />
</dependencies>

Le righe seguenti indicano dipendenze dagli stessi pacchetti, ma specificano di includere le cartelle contentFiles e build di PackageA e tutte le cartelle tranne native e compile di PackageB.The following lines indicate dependencies on the same packages, but specify to include the contentFiles and build folders of PackageA and everything but the native and compile folders of PackageB"

<dependencies>
    <dependency id="PackageA" version="1.1.0" include="contentFiles, build" />
    <dependency id="PackageB" version="[1,2)" exclude="native, compile" />
</dependencies>

Importante

Quando si crea .nuspec un oggetto da un nuget specprogetto usando, le dipendenze esistenti nel progetto non vengono incluse automaticamente nel .nuspec file risultante.When creating a .nuspec from a project using nuget spec, dependencies that exist in that project are not automatically included in the resulting .nuspec file. Usare nuget pack myproject.csprojinvece e ottenere il file con estensione NuSpec dall'interno del file nupkg generato.Instead, use nuget pack myproject.csproj, and get the .nuspec file from within the generated .nupkg file. Questo . NuSpec contiene le dipendenze.This .nuspec contains the dependencies.

Gruppi di dipendenzeDependency groups

Versione 2.0+Version 2.0+

In alternativa a un unico elenco semplice, è possibile specificare le dipendenze in base al profilo del framework del progetto di destinazione usando elementi <group> all'interno di <dependencies>.As an alternative to a single flat list, dependencies can be specified according to the framework profile of the target project using <group> elements within <dependencies>.

Ogni gruppo ha un attributo denominato targetFramework e contiene zero o più elementi <dependency>.Each group has an attribute named targetFramework and contains zero or more <dependency> elements. Tali dipendenze vengono installate insieme quando il framework di destinazione è compatibile con il profilo di framework del progetto.Those dependencies are installed together when the target framework is compatible with the project's framework profile.

L'elemento <group> senza un attributo targetFramework viene usato come elenco predefinito o di fallback delle dipendenze.The <group> element without a targetFramework attribute is used as the default or fallback list of dependencies. Vedere Framework di destinazione per gli identificatori di framework esatti.See Target frameworks for the exact framework identifiers.

Importante

Il formato di gruppo non può essere usato in combinazione con un elenco semplice.The group format cannot be intermixed with a flat list.

L'esempio seguente mostra variazioni diverse dell'elemento <group>:The following example shows different variations of the <group> element:

<dependencies>
    <group>
        <dependency id="RouteMagic" version="1.1.0" />
    </group>

    <group targetFramework="net40">
        <dependency id="jQuery" version="1.6.2" />
        <dependency id="WebActivator" version="1.4.4" />
    </group>

    <group targetFramework="sl30">
    </group>
</dependencies>

Riferimenti espliciti agli assemblyExplicit assembly references

L' <references> elemento viene usato dai progetti che packages.config usano per specificare in modo esplicito gli assembly a cui deve fare riferimento il progetto di destinazione quando si usa il pacchetto.The <references> element is used by projects using packages.config to explicitly specify the assemblies that the target project should reference when using the package. I riferimenti espliciti vengono generalmente usati per gli assembly solo della fase di progettazione.Explicit references are typically used for design-time only assemblies. Per ulteriori informazioni, vedere la pagina relativa alla selezione degli assembly a cui fanno riferimento i progetti .For more information, see the page on selecting assemblies referenced by projects for more information.

Ad esempio, l'elemento <references> seguente indica a NuGet di aggiungere riferimenti solo a xunit.dll e a xunit.extensions.dll anche se sono presenti altri assembly nel pacchetto:For example, the following <references> element instructs NuGet to add references to only xunit.dll and xunit.extensions.dll even if there are additional assemblies in the package:

<references>
    <reference file="xunit.dll" />
    <reference file="xunit.extensions.dll" />
</references>

Gruppi di riferimentiReference groups

In alternativa a un unico elenco semplice, è possibile specificare i riferimenti in base al profilo del framework del progetto di destinazione usando elementi <group> all'interno di <references>.As an alternative to a single flat list, references can be specified according to the framework profile of the target project using <group> elements within <references>.

Ogni gruppo ha un attributo denominato targetFramework e contiene zero o più elementi <reference>.Each group has an attribute named targetFramework and contains zero or more <reference> elements. Tali riferimenti vengono aggiunti a un progetto quando il framework di destinazione è compatibile con il profilo di framework del progetto.Those references are added to a project when the target framework is compatible with the project's framework profile.

L'elemento <group> senza un attributo targetFramework viene usato come elenco predefinito o di fallback dei riferimenti.The <group> element without a targetFramework attribute is used as the default or fallback list of references. Vedere Framework di destinazione per gli identificatori di framework esatti.See Target frameworks for the exact framework identifiers.

Importante

Il formato di gruppo non può essere usato in combinazione con un elenco semplice.The group format cannot be intermixed with a flat list.

L'esempio seguente mostra variazioni diverse dell'elemento <group>:The following example shows different variations of the <group> element:

<references>
    <group>
        <reference file="a.dll" />
    </group>

    <group targetFramework="net45">
        <reference file="b45.dll" />
    </group>

    <group targetFramework="netcore45">
        <reference file="bcore45.dll" />
    </group>
</references>

Riferimenti agli assembly del frameworkFramework assembly references

Gli assembly del framework sono quelli che fanno parte di .NET Framework e devono essere già presenti nella Global Assembly Cache (GAC) per qualsiasi computer.Framework assemblies are those that are part of the .NET framework and should already be in the global assembly cache (GAC) for any given machine. Grazie all'identificazione di tali assembly all'interno dell'elemento <frameworkAssemblies>, un pacchetto può garantire che i riferimenti necessari vengano aggiunti a un progetto nel caso in cui il progetto non includa già tali riferimenti.By identifying those assemblies within the <frameworkAssemblies> element, a package can ensure that required references are added to a project in the event that the project doesn't have such references already. Tali assembly, ovviamente, non vengono inclusi in un pacchetto direttamente.Such assemblies, of course, are not included in a package directly.

L'elemento <frameworkAssemblies> contiene zero o più elementi <frameworkAssembly>, ognuno dei quali specifica gli attributi seguenti:The <frameworkAssemblies> element contains zero or more <frameworkAssembly> elements, each of which specifies the following attributes:

AttributoAttribute DescrizioneDescription
assemblyNameassemblyName (Obbligatorio) Nome completo dell'assembly.(Required) The fully qualified assembly name.
targetFrameworktargetFramework (Facoltativo) Specifica il framework di destinazione a cui si applica questo riferimento.(Optional) Specifies the target framework to which this reference applies. Se omesso, indica che il riferimento si applica a tutti i framework.If omitted, indicates that the reference applies to all frameworks. Vedere Framework di destinazione per gli identificatori di framework esatti.See Target frameworks for the exact framework identifiers.

L'esempio seguente mostra un riferimento a System.Net per tutti i framework di destinazione e un riferimento a System.ServiceModel solo per .NET Framework 4.0:The following example shows a reference to System.Net for all target frameworks, and a reference to System.ServiceModel for .NET Framework 4.0 only:

<frameworkAssemblies>
    <frameworkAssembly assemblyName="System.Net"  />

    <frameworkAssembly assemblyName="System.ServiceModel" targetFramework="net40" />
</frameworkAssemblies>

Inclusione di file di assemblyIncluding assembly files

Se si seguono le convenzioni descritte in Creazione di un pacchetto, non è necessario specificare in modo esplicito un elenco di file nel file .nuspec.If you follow the conventions described in Creating a Package, you do not have to explicitly specify a list of files in the .nuspec file. Il comando nuget pack rileva automaticamente i file necessari.The nuget pack command automatically picks up the necessary files.

Importante

Quando un pacchetto viene installato in un progetto, NuGet aggiunge automaticamente i riferimenti agli assembly alle DLL del pacchetto, escludendo quelli denominati .resources.dll perché si presuppone che siano assembly satellite localizzati.When a package is installed into a project, NuGet automatically adds assembly references to the package's DLLs, excluding those that are named .resources.dll because they are assumed to be localized satellite assemblies. Per questo motivo, evitare di usare .resources.dll per i file che contengono invece codice essenziale per il pacchetto.For this reason, avoid using .resources.dll for files that otherwise contain essential package code.

Per evitare questo comportamento automatico e controllare in modo esplicito quali file vengono inclusi in un pacchetto, posizionare un elemento <files> come elemento figlio di <package> (ed elemento di pari livello di <metadata>), identificando ogni file con un elemento <file> separato.To bypass this automatic behavior and explicitly control which files are included in a package, place a <files> element as a child of <package> (and a sibling of <metadata>), identifying each file with a separate <file> element. Ad esempio:For example:

<files>
    <file src="bin\Debug\*.dll" target="lib" />
    <file src="bin\Debug\*.pdb" target="lib" />
    <file src="tools\**\*.*" exclude="**\*.log" />
</files>

Con NuGet 2.x e versioni precedenti e i progetti che usano packages.config, l'elemento <files> viene usato anche per includere file di contenuto non modificabili quando viene installato un pacchetto.With NuGet 2.x and earlier, and projects using packages.config, the <files> element is also used to include immutable content files when a package is installed. Con NuGet 3.3 + e PackageReference per i progetti, viene invece usato l'elemento <contentFiles>.With NuGet 3.3+ and projects PackageReference, the <contentFiles> element is used instead. Vedere Inclusione di file di contenuto di seguito per informazioni dettagliate.See Including content files below for details.

Attributi dell'elemento fileFile element attributes

Ogni elemento <file> specifica gli attributi seguenti:Each <file> element specifies the following attributes:

AttributoAttribute DescrizioneDescription
srcsrc Percorso del file o dei file da includere, soggetto alle esclusioni specificate dall'attributo exclude.The location of the file or files to include, subject to exclusions specified by the exclude attribute. Il percorso è relativo al file .nuspec, a meno che non venga specificato un percorso assoluto.The path is relative to the .nuspec file unless an absolute path is specified. Il carattere jolly * è consentito e il carattere jolly doppio ** implica una ricerca ricorsiva nelle cartelle.The wildcard character * is allowed, and the double wildcard ** implies a recursive folder search.
targettarget Percorso relativo della cartella all'interno del pacchetto in cui vengono collocati i file di origine, che deve iniziare con lib, content, build o tools.The relative path to the folder within the package where the source files are placed, which must begin with lib, content, build, or tools. Vedere Creazione di un file .nuspec da una directory di lavoro basata su convenzioni.See Creating a .nuspec from a convention-based working directory.
excludeexclude Elenco delimitato da punti e virgola dei file o dei modelli di file da escludere dal percorso src.A semicolon-delimited list of files or file patterns to exclude from the src location. Il carattere jolly * è consentito e il carattere jolly doppio ** implica una ricerca ricorsiva nelle cartelle.The wildcard character * is allowed, and the double wildcard ** implies a recursive folder search.

EsempiExamples

Singolo assemblySingle assembly

Source file:
    library.dll

.nuspec entry:
    <file src="library.dll" target="lib" />

Packaged result:
    lib\library.dll

Singolo assembly specifico di un framework di destinazioneSingle assembly specific to a target framework

Source file:
    library.dll

.nuspec entry:
    <file src="assemblies\net40\library.dll" target="lib\net40" />

Packaged result:
    lib\net40\library.dll

Set di DLL con un carattere jollySet of DLLs using a wildcard

Source files:
    bin\release\libraryA.dll
    bin\release\libraryB.dll

.nuspec entry:
    <file src="bin\release\*.dll" target="lib" />

Packaged result:
    lib\libraryA.dll
    lib\libraryB.dll

DLL per framework diversiDLLs for different frameworks

Source files:
    lib\net40\library.dll
    lib\net20\library.dll

.nuspec entry (using ** recursive search):
    <file src="lib\**" target="lib" />

Packaged result:
    lib\net40\library.dll
    lib\net20\library.dll

Esclusione di fileExcluding files

Source files:
    \tools\fileA.bak
    \tools\fileB.bak
    \tools\fileA.log
    \tools\build\fileB.log

.nuspec entries:
    <file src="tools\*.*" target="tools" exclude="tools\*.bak" />
    <file src="tools\**\*.*" target="tools" exclude="**\*.log" />

Package result:
    (no files)

Inclusione di file di contenutoIncluding content files

I file di contenuto sono file non modificabili che un pacchetto deve includere in un progetto.Content files are immutable files that a package needs to include in a project. Essendo non modificabili, non sono progettati per essere modificati dal progetto che li utilizza.Being immutable, they are not intended to be modified by the consuming project. Alcuni esempi di file di contenuto includono:Example content files include:

  • Immagini incorporate come risorseImages that are embedded as resources
  • File di origine già compilatiSource files that are already compiled
  • Script che devono essere inclusi con l'output di compilazione del progettoScripts that need to be included with the build output of the project
  • File di configurazione per il pacchetto che devono essere inclusi nel progetto ma non richiedono modifiche specifiche del progettoConfiguration files for the package that need to be included in the project but don't need any project-specific changes

I file di contenuto vengono inclusi in un pacchetto con l'elemento <files>, specificando la cartella content nell'attributo target.Content files are included in a package using the <files> element, specifying the content folder in the target attribute. Questi file vengono tuttavia ignorati quando il pacchetto viene installato in un progetto usando PackageReference, che usa invece l'elemento <contentFiles>.However, such files are ignored when the package is installed in a project using PackageReference, which instead uses the <contentFiles> element.

Per ottenere la massima compatibilità con i progetti in cui viene utilizzato, un pacchetto specifica idealmente i file di contenuto in entrambi gli elementi.For maximum compatibility with consuming projects, a package ideally specifies the content files in both elements.

Uso dell'elemento files per i file di contenutoUsing the files element for content files

Per i file di contenuto, usare semplicemente lo stesso formato usato per i file di assembly, ma specificare content come cartella di base nell'attributo target, come illustrato negli esempi seguenti.For content files, simply use the same format as for assembly files, but specify content as the base folder in the target attribute as shown in the following examples.

File di contenuto sempliciBasic content files

Source files:
    css\mobile\style1.css
    css\mobile\style2.css

.nuspec entry:
    <file src="css\mobile\*.css" target="content\css\mobile" />

Packaged result:
    content\css\mobile\style1.css
    content\css\mobile\style2.css

File di contenuto con struttura di directoryContent files with directory structure

Source files:
    css\mobile\style.css
    css\mobile\wp7\style.css
    css\browser\style.css

.nuspec entry:
    <file src="css\**\*.css" target="content\css" />

Packaged result:
    content\css\mobile\style.css
    content\css\mobile\wp7\style.css
    content\css\browser\style.css

File di contenuto specifico di un framework di destinazioneContent file specific to a target framework

Source file:
    css\cool\style.css

.nuspec entry
    <file src="css\cool\style.css" target="Content" />

Packaged result:
    content\style.css

File di contenuto copiato in una cartella con un punto nel nomeContent file copied to a folder with dot in name

In questo caso, NuGet rileva che l'estensione in target non corrisponde all'estensione in src, quindi interpreta la parte del nome in target come cartella:In this case, NuGet sees that the extension in target does not match the extension in src and thus treats that part of the name in target as a folder:

Source file:
    images\picture.png

.nuspec entry:
    <file src="images\picture.png" target="Content\images\package.icons" />

Packaged result:
    content\images\package.icons\picture.png

File di contenuto senza estensioneContent files without extensions

Per includere i file senza estensione, usare i caratteri jolly * o **:To include files without an extension, use the * or ** wildcards:

Source file:
    flags\installed

.nuspec entry:
    <file src="flags\**" target="flags" />

Packaged result:
    flags\installed

File di contenuto con percorso completo e destinazione completaContent files with deep path and deep target

In questo caso, dato che le estensioni dei file di origine e di destinazione corrispondono, NuGet presuppone che la destinazione sia un nome di file e non una cartella:In this case, because the file extensions of the source and target match, NuGet assumes that the target is a file name and not a folder:

Source file:
    css\cool\style.css

.nuspec entry:
    <file src="css\cool\style.css" target="Content\css\cool" />
    or:
    <file src="css\cool\style.css" target="Content\css\cool\style.css" />

Packaged result:
    content\css\cool\style.css

Ridenominazione di un file di contenuto nel pacchettoRenaming a content file in the package

Source file:
    ie\css\style.css

.nuspec entry:
    <file src="ie\css\style.css" target="Content\css\ie.css" />

Packaged result:
    content\css\ie.css

Esclusione di fileExcluding files

Source file:
    docs\*.txt (multiple files)

.nuspec entry:
    <file src="docs\*.txt" target="content\docs" exclude="docs\admin.txt" />
    or
    <file src="*.txt" target="content\docs" exclude="admin.txt;log.txt" />

Packaged result:
    All .txt files from docs except admin.txt (first example)
    All .txt files from docs except admin.txt and log.txt (second example)

Uso dell'elemento contentFiles per i file di contenutoUsing the contentFiles element for content files

NuGet 4.0 + con PackageReferenceNuGet 4.0+ with PackageReference

Per impostazione predefinita, un pacchetto inserisce il contenuto in una cartella contentFiles (vedere di seguito) e nuget pack include tutti i file nella cartella usando gli attributi predefiniti.By default, a package places content in a contentFiles folder (see below) and nuget pack included all files in that folder using default attributes. In questo caso non è affatto necessario includere un nodo contentFiles nel file .nuspec.In this case it's not necessary to include a contentFiles node in the .nuspec at all.

Per controllare quali file sono inclusi, l'elemento <contentFiles> specifica una raccolta di elementi <files> che identificano i file esatti inclusi.To control which files are included, the <contentFiles> element specifies is a collection of <files> elements that identify the exact files include.

Questi file sono specificati con un set di attributi che descrivono come devono essere usati all'interno del sistema del progetto:These files are specified with a set of attributes that describe how they should be used within the project system:

AttributoAttribute DescrizioneDescription
includeinclude (Obbligatorio) Percorso del file o dei file da includere, soggetto alle esclusioni specificate dall'attributo exclude.(Required) The location of the file or files to include, subject to exclusions specified by the exclude attribute. Il percorso è relativo alla contentFiles cartella, a meno che non sia specificato un percorso assoluto.The path is relative to the contentFiles folder unless an absolute path is specified. Il carattere jolly * è consentito e il carattere jolly doppio ** implica una ricerca ricorsiva nelle cartelle.The wildcard character * is allowed, and the double wildcard ** implies a recursive folder search.
excludeexclude Elenco delimitato da punti e virgola dei file o dei modelli di file da escludere dal percorso src.A semicolon-delimited list of files or file patterns to exclude from the src location. Il carattere jolly * è consentito e il carattere jolly doppio ** implica una ricerca ricorsiva nelle cartelle.The wildcard character * is allowed, and the double wildcard ** implies a recursive folder search.
buildActionbuildAction Azione di compilazione da assegnare all'elemento di contenuto per MSBuild, ad esempio Content, None, Embedded Resource, Compile e così via. Il valore predefinito è Compile.The build action to assign to the content item for MSBuild, such as Content, None, Embedded Resource, Compile, etc. The default is Compile.
copyToOutputcopyToOutput Valore booleano che indica se copiare gli elementi di contenuto nella cartella di output di compilazione o pubblicazione.A Boolean indicating whether to copy content items to the build (or publish) output folder. Il valore predefinito è false.The default is false.
flattenflatten Valore booleano che indica se copiare gli elementi di contenuto di una singola cartella nell'output di compilazione (true) o se mantenere la struttura di cartelle nel pacchetto (false).A Boolean indicating whether to copy content items to a single folder in the build output (true), or to preserve the folder structure in the package (false). Questo flag funziona solo quando il flag copyToOutput è impostato su true.This flag only works when copyToOutput flag is set to true. Il valore predefinito è false.The default is false.

Quando si installa un pacchetto, NuGet applica gli elementi figlio di <contentFiles> dall'alto verso il basso.When installing a package, NuGet applies the child elements of <contentFiles> from top to bottom. Se più voci corrispondono allo stesso file, vengono applicate tutte le voci.If multiple entries match the same file then all entries are applied. La voce di livello superiore sostituisce le voci inferiori in presenza di un conflitto per lo stesso attributo.The top-most entry overrides the lower entries if there is a conflict for the same attribute.

Struttura delle cartelle del pacchettoPackage folder structure

Il progetto del pacchetto deve strutturare il contenuto in base al modello seguente:The package project should structure content using the following pattern:

/contentFiles/{codeLanguage}/{TxM}/{any?}
  • codeLanguages può essere cs, vb, fs, any o l'equivalente in caratteri minuscoli di uno specifico $(ProjectLanguage)codeLanguages may be cs, vb, fs, any, or the lowercase equivalent of a given $(ProjectLanguage)
  • TxM è qualsiasi moniker di framework di destinazione valido supportato da NuGet (vedere Framework di destinazione).TxM is any legal target framework moniker that NuGet supports (see Target frameworks).
  • Qualsiasi struttura di cartelle può essere aggiunta alla fine di questa sintassi.Any folder structure may be appended to the end of this syntax.

Ad esempio:For example:

Language- and framework-agnostic:
    /contentFiles/any/any/config.xml

net45 content for all languages
    /contentFiles/any/net45/config.xml

C#-specific content for net45 and up
    /contentFiles/cs/net45/sample.cs

Le cartelle vuote possono usare . per rifiutare esplicitamente di fornire contenuti per determinate combinazioni di linguaggio e TxM, ad esempio:Empty folders can use . to opt out of providing content for certain combinations of language and TxM, for example:

/contentFiles/vb/any/code.vb
/contentFiles/cs/any/.

Sezione di esempio contentFilesExample contentFiles section

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        ...
        <contentFiles>
            <!-- Embed image resources -->
            <files include="any/any/images/dnf.png" buildAction="EmbeddedResource" />
            <files include="any/any/images/ui.png" buildAction="EmbeddedResource" />

            <!-- Embed all image resources under contentFiles/cs/ -->
            <files include="cs/**/*.png" buildAction="EmbeddedResource" />

            <!-- Copy config.xml to the root of the output folder -->
            <files include="cs/uap/config/config.xml" buildAction="None" copyToOutput="true" flatten="true" />

            <!-- Copy run.cmd to the output folder and keep the directory structure -->
            <files include="cs/commands/run.cmd" buildAction="None" copyToOutput="true" flatten="false" />

            <!-- Include everything in the scripts folder except exe files -->
            <files include="cs/net45/scripts/*" exclude="**/*.exe"  buildAction="None" copyToOutput="true" />
        </contentFiles>
        </metadata>
</package>

File nuspec di esempioExample nuspec files

File .nuspec semplice che non specifica dipendenze o fileA simple .nuspec that does not specify dependencies or files

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        <id>sample</id>
        <version>1.2.3</version>
        <authors>Kim Abercrombie, Franck Halmaert</authors>
        <description>Sample exists only to show a sample .nuspec file.</description>
        <language>en-US</language>
        <projectUrl>http://xunit.codeplex.com/</projectUrl>
        <license type="expression">MIT</license>
    </metadata>
</package>

File .nuspec con dipendenzeA .nuspec with dependencies

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        <id>sample</id>
        <version>1.0.0</version>
        <authors>Microsoft</authors>
        <dependencies>
            <dependency id="another-package" version="3.0.0" />
            <dependency id="yet-another-package" version="1.0.0" />
        </dependencies>
    </metadata>
</package>

File .nuspec con fileA .nuspec with files

<?xml version="1.0"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        <id>routedebugger</id>
        <version>1.0.0</version>
        <authors>Jay Hamlin</authors>
        <requireLicenseAcceptance>false</requireLicenseAcceptance>
        <description>Route Debugger is a little utility I wrote...</description>
    </metadata>
    <files>
        <file src="bin\Debug\*.dll" target="lib" />
    </files>
</package>

File .nuspec con assembly di frameworkA .nuspec with framework assemblies

<?xml version="1.0"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <metadata>
        <id>PackageWithGacReferences</id>
        <version>1.0</version>
        <authors>Author here</authors>
        <requireLicenseAcceptance>false</requireLicenseAcceptance>
        <description>
            A package that has framework assemblyReferences depending
            on the target framework.
        </description>
        <frameworkAssemblies>
            <frameworkAssembly assemblyName="System.Web" targetFramework="net40" />
            <frameworkAssembly assemblyName="System.Net" targetFramework="net40-client, net40" />
            <frameworkAssembly assemblyName="Microsoft.Devices.Sensors" targetFramework="sl4-wp" />
            <frameworkAssembly assemblyName="System.Json" targetFramework="sl3" />
        </frameworkAssemblies>
    </metadata>
</package>

In questo esempio vengono installati i componenti seguenti per destinazioni di progetto specifiche:In this example, the following are installed for specific project targets:

  • .NET4 -> System.Web, System.Net.NET4 -> System.Web, System.Net
  • .NET4 Client Profile -> System.Net.NET4 Client Profile -> System.Net
  • Silverlight 3 -> System.JsonSilverlight 3 -> System.Json
  • WindowsPhone -> Microsoft.Devices.SensorsWindowsPhone -> Microsoft.Devices.Sensors