/LinkResource dans Visual Studio 2010

Question

/linkresource est une option csc qui permet de lier un assembly à ses dépendances non managées. Lorsque l'assembly géré est ajouté au GAC, les dépendances sont placées dans le même dossier. Voici comment tous les wrappers .NET doivent être installés ...

Il existe très peu d'informations sur la façon de procéder dans Visual Studio. Il n'y a pas de réponse officielle, juste des gens qui ont piraté une solution. Par exemple http://www.netframeworkdev.com/msbuild/msbuild-linkresource-nonassembly-external-file-beforecompile-24358.shtml. Cela a l'habitude de travailler sur VS2008 mais il semble que cela ne fonctionne pas sur VS2010 ...: -/

Est-ce que VS2010 supporte LinkResources d'une manière simple et propre?

Merci à l'avance, aalmada

Answer 1

moi avons réussi à obtenir que cela fonctionne dans VS2010 mais avec des avertissements.

1) Remplacer CoreCompile pour ajouter LinkResources

2) Ajouter une cible pour obtenir l'équivalent de copie locale sur quoi que ce soit ajouté que <LinkResource Include="native.dll" />

3) Si le projet contenant le natif bibliothèques/fichier contient uniquement ces fichiers, ajoutez un type/interface. Utilisez ce type dans le projet en utilisant les références. C'est à dire. le projet dans lequel vous utilisez DllImport. Cela empêche le compilateur d'optimiser la dépendance du projet.

4) Tack sur de Alex Yakounine trick pour copier les dépendances du projet.

Cela tire toutes les dépendances dans mon $ (TargetDir) prêt pour le débogage.

Dans les fichiers de projet, j'importer la magie après les cibles régulières des fichiers ala

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> 
    <Import Project="$(ProjectDir)..\..\External\CopyDependencies.targets" /> 

et j'ai CopyDependencies.targets comme suit:

<?xml version="1.0" encoding="utf-8"?> 
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 

    <Target 
    Name="CoreCompile" 
    Inputs="$(MSBuildAllProjects); 
       @(Compile);        
       @(_CoreCompileResourceInputs); 
       $(ApplicationIcon); 
       $(AssemblyOriginatorKeyFile); 
       @(ReferencePath); 
       @(CompiledLicenseFile); 
       @(EmbeddedDocumentation); 
       $(Win32Resource); 
       $(Win32Manifest); 
       @(LinkResource); 
       @(CustomAdditionalCompileInputs)" 
    Outputs="@(DocFileItem); 
       @(IntermediateAssembly); 
       @(_DebugSymbolsIntermediatePath);     
       $(NonExistentFile); 
       @(CustomAdditionalCompileOutputs)" 
    Returns="" 
    DependsOnTargets="$(CoreCompileDependsOn)" 
    > 
    <!-- These two compiler warnings are raised when a reference is bound to a different version 
      than specified in the assembly reference version number. MSBuild raises the same warning in this case, 
      so the compiler warning would be redundant. --> 
    <PropertyGroup Condition="('$(TargetFrameworkVersion)' != 'v1.0') and ('$(TargetFrameworkVersion)' != 'v1.1')"> 
     <NoWarn>$(NoWarn);1701;1702</NoWarn> 
    </PropertyGroup> 

    <PropertyGroup> 
     <!-- If we are building in visual studio setting the CscToolPath will prevent the inproc compiler from being used during compile--> 
     <CscToolPath Condition="'$(CscToolPath)' == '' and '$(BuildingInsideVisualStudio)' != 'true'" >$(MsBuildToolsPath)</CscToolPath> 
    </PropertyGroup> 

    <ItemGroup Condition="'$(TargetingClr2Framework)'=='true'"> 
     <ReferencePath> 
     <EmbedInteropTypes/> 
     </ReferencePath> 
    </ItemGroup> 

    <PropertyGroup> 
     <!-- If the user has specified AppConfigForCompiler, we'll use it. If they have not, but they set UseAppConfigForCompiler, 
       then we'll use AppConfig --> 
     <AppConfigForCompiler Condition="'$(AppConfigForCompiler)' == '' and '$(UseAppConfigForCompiler)' == 'true'">$(AppConfig)</AppConfigForCompiler> 
    </PropertyGroup> 

    <!-- Condition is to filter out the _CoreCompileResourceInputs so that it doesn't pass in culture resources to the compiler --> 
    <Csc Condition=" '%(_CoreCompileResourceInputs.WithCulture)' != 'true' " 
      AdditionalLibPaths="$(AdditionalLibPaths)" 
      AddModules="@(AddModules)" 
      AllowUnsafeBlocks="$(AllowUnsafeBlocks)" 
      ApplicationConfiguration="$(AppConfigForCompiler)" 
      BaseAddress="$(BaseAddress)" 
      CheckForOverflowUnderflow="$(CheckForOverflowUnderflow)" 
      CodePage="$(CodePage)" 
      DebugType="$(DebugType)" 
      DefineConstants="$(DefineConstants)" 
      DelaySign="$(DelaySign)" 
      DisabledWarnings="$(NoWarn)" 
      DocumentationFile="@(DocFileItem)" 
      EmitDebugInformation="$(DebugSymbols)" 
      ErrorReport="$(ErrorReport)" 
      FileAlignment="$(FileAlignment)" 
      GenerateFullPaths="$(GenerateFullPaths)" 
      KeyContainer="$(KeyContainerName)" 
      KeyFile="$(KeyOriginatorFile)" 
      LangVersion="$(LangVersion)" 
      LinkResources="@(LinkResource)" 
      MainEntryPoint="$(StartupObject)" 
      ModuleAssemblyName="$(ModuleAssemblyName)" 
      NoConfig="true" 
      NoLogo="$(NoLogo)" 
      NoStandardLib="$(NoCompilerStandardLib)" 
      NoWin32Manifest="$(NoWin32Manifest)" 
      Optimize="$(Optimize)" 
      OutputAssembly="@(IntermediateAssembly)" 
      PdbFile="$(PdbFile)" 
      Platform="$(PlatformTarget)" 
      References="@(ReferencePath)" 
      Resources="@(_CoreCompileResourceInputs);@(CompiledLicenseFile)" 
      ResponseFiles="$(CompilerResponseFile)" 
      Sources="@(Compile)" 
      TargetType="$(OutputType)" 
      ToolExe="$(CscToolExe)" 
      ToolPath="$(CscToolPath)" 
      TreatWarningsAsErrors="$(TreatWarningsAsErrors)" 
      UseHostCompilerIfAvailable="$(UseHostCompilerIfAvailable)" 
      Utf8Output="$(Utf8Output)" 
      WarningLevel="$(WarningLevel)" 
      WarningsAsErrors="$(WarningsAsErrors)" 
      WarningsNotAsErrors="$(WarningsNotAsErrors)" 
      Win32Icon="$(ApplicationIcon)" 
      Win32Manifest="$(Win32Manifest)" 
      Win32Resource="$(Win32Resource)" 

       /> 

    <ItemGroup> 
     <_CoreCompileResourceInputs Remove="@(_CoreCompileResourceInputs)" /> 
    </ItemGroup> 

    <CallTarget Targets="$(TargetsTriggeredByCompilation)" Condition="'$(TargetsTriggeredByCompilation)' != ''"/> 

    </Target> 


    <PropertyGroup> 
    <CopyLinkedResources Condition="'$(CopyLinkedResources)'==''">true</CopyLinkedResources> 
    </PropertyGroup> 

    <PropertyGroup> 
    <CopyDependencies 
     Condition="'$(CopyDependencies)'==''">true</CopyDependencies> 
    <CopyDependenciesPdb 
     Condition="'$(CopyDependenciesPdb)'==''">true</CopyDependenciesPdb> 
    <CopyDependenciesXml 
     Condition="'$(CopyDependenciesXml)'==''">true</CopyDependenciesXml> 
    </PropertyGroup> 


    <Target Name="CopyLinkedResources"> 
    <Message Text="Copy Linked Resources"></Message> 
    <Copy SourceFiles="@(LinkResource->'%(FullPath)')" 
      DestinationFolder="$(OutputPath)" 
      SkipUnchangedFiles="true"> 
     <Output TaskParameter="CopiedFiles" 
     ItemName="LinkResourceCopied" /> 
    </Copy> 
    <Message Text="Copy Linked Resource: %(LinkResourceCopied.FullPath)" Importance="low"/> 
    </Target> 



<Target Name="CopyIndirectDependencies" 
      Condition="'$(CopyIndirectDependencies)'=='true'" 
      DependsOnTargets="DetectIndirectDependencies" 
      Inputs="@(IndirectDependencyToCopy)" 
      Outputs="@(MatchingOutputDependency)"> 
    <Copy SourceFiles="@(IndirectDependencyToCopy)" 
      DestinationFiles="@(MatchingOutputDependency)" 
      SkipUnchangedFiles="true"> 
     <Output TaskParameter="CopiedFiles" 
       ItemName="IndirectDependencyCopied" /> 
    </Copy> 
    <Message Importance="low" 
      Condition="'%(IndirectDependencyCopied.FullPath)'!='' 
         and '%(IndirectDependencyCopied.Extension)'!='.pdb' 
         and '%(IndirectDependencyCopied.Extension)'!='.xml'" 
      Text="Indirect dependency copied: %(IndirectDependencyCopied.FullPath)" /> 
    </Target> 

    <Target Name="DetectIndirectDependencies" 
      DependsOnTargets="ResolveAssemblyReferences"> 

    <Message Importance="low" 
      Text="Direct dependency: %(ReferencePath.Filename)%(ReferencePath.Extension)" /> 
    <Message Importance="low" 
      Text="Indirect dependency: %(ReferenceDependencyPaths.Filename)%(ReferenceDependencyPaths.Extension)" /> 

    <!-- Creating indirect dependency list --> 
    <ItemGroup> 
     <DetectedIndirectDependency Include="%(ReferenceDependencyPaths.FullPath)" 
            Condition="'%(ReferenceDependencyPaths.CopyLocal)'=='true'"/> 
    </ItemGroup> 

    <ItemGroup Condition="'$(CopyIndirectDependenciesXml)'=='true'"> 
     <DetectedIndirectDependency Include="%(ReferenceDependencyPaths.RootDir)%(ReferenceDependencyPaths.Directory)%(ReferenceDependencyPaths.Filename).xml" 
            Condition="'%(ReferenceDependencyPaths.CopyLocal)'=='true'" /> 
    </ItemGroup> 

    <ItemGroup Condition="'$(CopyIndirectDependenciesPdb)'=='true'"> 
     <DetectedIndirectDependency Include="%(ReferenceDependencyPaths.RootDir)%(ReferenceDependencyPaths.Directory)%(ReferenceDependencyPaths.Filename).pdb" 
            Condition="'%(ReferenceDependencyPaths.CopyLocal)'=='true'"/> 
    </ItemGroup> 


    <!-- Work out which dependencies actually exist in the file system --> 
    <ItemGroup> 
     <IndirectDependencyToCopy Include="@(DetectedIndirectDependency)" 
            Condition="Exists('%(DetectedIndirectDependency.Identity)')" />   

     <MatchingOutputDependency Include="@(IndirectDependencyToCopy->'$(OutputPath)%(Filename)%(Extension)')" /> 
    </ItemGroup> 

    </Target> 

    <!-- Build sequence modification --> 

    <PropertyGroup> 
    <CoreBuildDependsOn> 
     $(CoreBuildDependsOn); 
     CopyDependencies; 
     CopyLinkedResources 
    </CoreBuildDependsOn> 
    </PropertyGroup> 
</Project>