वाईएक्स ट्रिक्स और टिप्स


264

हम थोड़ी देर के लिए वाईएक्स का उपयोग कर रहे हैं, और उपयोग में आसानी के बारे में सामान्य पकड़ के बावजूद, यह काफी अच्छी तरह से चल रहा है। मैं जो देख रहा हूँ वह उपयोगी सलाह है:

  • वाईएक्स प्रोजेक्ट स्थापित करना (लेआउट, संदर्भ, फ़ाइल पैटर्न)
  • समाधानों में वाईएक्स को एकीकृत करना, और प्रक्रियाओं का निर्माण / रिलीज करना
  • नए इंस्टॉलेशन और अपग्रेड के लिए इंस्टॉलर को कॉन्फ़िगर करना
  • कोई भी अच्छा वाईएक्स हैक जिसे आप साझा करना चाहते हैं

gui4wix.codeplex.com
TarunG

10
रचनात्मक नहीं के रूप में बंद? मैंने यह सवाल पूछने से बहुत कुछ सीखा है! StackOverflow से थोड़ी स्थिरता भी अच्छी होगी ... जैसे stackoverflow.com/questions/550632/…
si618

15
इसे '203' अप मिला, इसकी उपयोगिता साबित करने के लिए यह पर्याप्त है।
तरुण

SO प्रश्नों का निश्चित, सही उत्तर होना चाहिए; ओपन-एंडेड प्रश्न उन लोगों से सवाल पूछते हैं जो वास्तविक समस्याओं के बारे में फ्रंट पेज से पूछते हैं। faq @Si: वह नीति हमेशा AFAIK रही है, लेकिन यह अब बेहतर है; यह सवाल लगभग तीन साल पुराना है।
जिम डग्ग

फेयर पर्याप्त जिम, यह एक खुला हुआ प्रश्न है, और मुझे लगता है कि यह एसओ समुदाय के लिए तय करना है, लेकिन मेरा कहना है कि इसे बंद करने के रूप में रचनात्मक नहीं लगता है, यह देखते हुए कि मैं और इसके द्वारा, कई अन्य लोग यह प्रश्न उपयोगी है (जैसे goo.gl/Zqp2X ), और यह practical, answerable questions based on actual problems that you faceअक्सर पूछे जाने वाले प्रश्न के भाग के साथ बहुत अच्छी तरह से फिट बैठता है ।
si618

जवाबों:


157
  1. चर को एक अलग wxiफ़ाइल में रखें । पुन: उपयोग करने में सक्षम करता है, चर तेजी से खोजने के लिए और (यदि आवश्यक हो) एक बाहरी उपकरण द्वारा आसान हेरफेर के लिए अनुमति देता है।

  2. X86 और x64 बिल्ड के लिए प्लेटफ़ॉर्म चर को परिभाषित करें

    <!-- Product name as you want it to appear in Add/Remove Programs-->
    <?if $(var.Platform) = x64 ?>
      <?define ProductName = "Product Name (64 bit)" ?>
      <?define Win64 = "yes" ?>
      <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
    <?else ?>
      <?define ProductName = "Product Name" ?>
      <?define Win64 = "no" ?>
      <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
    <?endif ?>
  3. रजिस्ट्री में स्थापना स्थान को स्टोर करें, सही स्थान खोजने के लिए उन्नयन को सक्षम करें। उदाहरण के लिए, यदि कोई उपयोगकर्ता कस्टम इंस्टॉल निर्देशिका सेट करता है।

     <Property Id="INSTALLLOCATION">
        <RegistrySearch Id="RegistrySearch" Type="raw" Root="HKLM" Win64="$(var.Win64)"
                  Key="Software\Company\Product" Name="InstallLocation" />
     </Property>

    नोट : वाईएक्स गुरु रॉब मेन्शचिंग ने एक उत्कृष्ट ब्लॉग प्रविष्टि पोस्ट की है जो अधिक विवरण में जाती है और एक किनारे के मामले को ठीक करती है जब संपत्तियों को कमांड लाइन से सेट किया जाता है।

    1. 2. और 3 का उपयोग करने वाले उदाहरण।

    <?include $(sys.CURRENTDIR)\Config.wxi?>
    <Product ... >
      <Package InstallerVersion="200" InstallPrivileges="elevated"
               InstallScope="perMachine" Platform="$(var.Platform)"
               Compressed="yes" Description="$(var.ProductName)" />

    तथा

    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="$(var.PlatformProgramFilesFolder)">
        <Directory Id="INSTALLLOCATION" Name="$(var.InstallName)">
  4. सरलतम दृष्टिकोण हमेशा प्रमुख उन्नयन करता है , क्योंकि यह एकल MSI में नए इंस्टाल और अपग्रेड दोनों की अनुमति देता है। जब तक हम मौजूदा उत्पाद को अपग्रेड नहीं करना चाहते, तब तक UpgradCode एक विशिष्ट दिशानिर्देश के लिए नियत है और कभी नहीं बदलेगा।

    नोट : वाईएक्स 3.5 में एक नया मेजरअपग्रेड तत्व है जो जीवन को और भी आसान बनाता है !

  5. प्रोग्राम जोड़ें / निकालें में एक आइकन बनाना

    <Icon Id="Company.ico" SourceFile="..\Tools\Company\Images\Company.ico" />
    <Property Id="ARPPRODUCTICON" Value="Company.ico" />
    <Property Id="ARPHELPLINK" Value="http://www.example.com/" />
  6. रिलीज़ होने पर, हम अपने इंस्टॉलरों को संस्करण देते हैं, एक तैनाती निर्देशिका में एमएसआई फ़ाइल की प्रतिलिपि बनाते हैं। AfterBuild लक्ष्य से बुलाया एक wixproj लक्ष्य का उपयोग कर इसका एक उदाहरण:

    <Target Name="CopyToDeploy" Condition="'$(Configuration)' == 'Release'">
      <!-- Note we append AssemblyFileVersion, changing MSI file name only works with Major Upgrades -->
      <Copy SourceFiles="$(OutputPath)$(OutputName).msi" 
            DestinationFiles="..\Deploy\Setup\$(OutputName) $(AssemblyFileVersion)_$(Platform).msi" />
    </Target>
  7. वाइल्डकार्ड (*) गाइड के साथ फाइलों को क्रॉप करने के लिए हीट का उपयोग करें। उपयोगी है यदि आप कई परियोजनाओं में WXS फ़ाइलों का पुन: उपयोग करना चाहते हैं (एक ही उत्पाद के कई संस्करणों पर मेरा उत्तर देखें)। उदाहरण के लिए, यह बैच फ़ाइल स्वतः ही RoboHelp आउटपुट की कटाई करती है।

    @echo off  
    robocopy ..\WebHelp "%TEMP%\WebHelpTemp\WebHelp" /E /NP /PURGE /XD .svn  
    "%WIX%bin\heat" dir "%TEMP%\WebHelp" -nologo -sfrag -suid -ag -srd -dir WebHelp -out WebHelp.wxs -cg WebHelpComponent -dr INSTALLLOCATION -var var.WebDeploySourceDir 

    वहाँ एक सा चल रहा है, robocopyकटाई से पहले तोड़फोड़ काम कॉपी मेटाडाटा बाहर कर रहा है; -drरूट निर्देशिका संदर्भ बल्कि डिफ़ॉल्ट TARGETDIR से हमारे स्थापना स्थान के लिए सेट है; -varस्रोत निर्देशिका (वेब ​​परिनियोजन आउटपुट) को निर्दिष्ट करने के लिए एक चर बनाने के लिए उपयोग किया जाता है।

  8. स्थानीयकरण के लिए Strings.wxl का उपयोग करके स्वागत संवाद शीर्षक में उत्पाद संस्करण को शामिल करने का आसान तरीका। ( साभार : saschabeaumont । जोड़ा गया यह शानदार टिप एक टिप्पणी में छिपा है)

    <WixLocalization Culture="en-US" xmlns="http://schemas.microsoft.com/wix/2006/localization">
        <String Id="WelcomeDlgTitle">{\WixUI_Font_Bigger}Welcome to the [ProductName] [ProductVersion] Setup Wizard</String>
    </WixLocalization>
  9. अपने आप को कुछ दर्द से बचाएं और प्रति फ़ाइल एक घटक की Wim Coehen की सलाह का पालन ​​करें । यह आपको घटक GUID को छोड़ने (या वाइल्ड-कार्ड *) की अनुमति भी देता है ।

  10. रॉब मेन्शचिंग के पास MSI लॉग फ़ाइलों को खोजने के लिए समस्याओं को जल्दी से ट्रैक करने का एक अच्छा तरीका है value 3। अंतर्राष्ट्रीयकरण से संबंधित टिप्पणियों पर ध्यान दें।

  11. सशर्त सुविधाओं को जोड़ते समय, डिफ़ॉल्ट सुविधा स्तर को 0 (अक्षम) पर सेट करना अधिक सहज है और फिर स्थिति स्तर को आपके इच्छित मान पर सेट करें। यदि आप डिफ़ॉल्ट फ़ीचर लेवल> = 1 सेट करते हैं, तो इसे डिसेबल करने के लिए कंडीशन लेवल 0 होना चाहिए, जिसका मतलब है कि लॉजिक आपकी अपेक्षा के विपरीत होगा, जो कन्फ्यूज़िंग हो सकता है :)

    <Feature Id="NewInstallFeature" Level="0" Description="New installation feature" Absent="allow">
      <Condition Level="1">NOT UPGRADEFOUND</Condition>
    </Feature>
    <Feature Id="UpgradeFeature" Level="0" Description="Upgrade feature" Absent="allow">
      <Condition Level="1">UPGRADEFOUND</Condition>
    </Feature>

प्रोग्राम जोड़ें / निकालें में आइकन जोड़ने के बारे में, यह वास्तव में मैं क्या देख रहा था। आप उन तीन लाइनों को कहाँ चिपकाते हैं? सरासर अजीब के लिए +1।
एवरेट

मैं उन्हें <पैकेज> तत्व के ठीक बाद (और नीचे स्पष्ट रूप से) जगह देता हूं। वैधता के लिए स्कीमा wix.sourceforge.net/manual-wix3/schema_index.htm
si618

+1, काश मैं +100 कर पाता, यह Wix जानकारी का सबसे उपयोगी बिट है जिस पर मैंने ठोकर खाई है।
टिम लॉन्ग

धन्यवाद टिम! रॉब मेन्शचिंग, बॉब एर्सन, विम कोहेन और अन्य अपने ज्ञान को साझा करने के लिए कुडोस के लायक हैं।
si618

38

IIS स्थापित है, तो जाँच:

<Property Id="IIS_MAJOR_VERSION">
    <RegistrySearch Id="CheckIISVersion" Root="HKLM" Key="SOFTWARE\Microsoft\InetStp" Name="MajorVersion" Type="raw" />
</Property>

<Condition Message="IIS must be installed">
    Installed OR IIS_MAJOR_VERSION
</Condition>

यदि Vista 6 पर IIS 6 मेटाबेस संगतता स्थापित की गई है तो जाँच:

<Property Id="IIS_METABASE_COMPAT">
    <RegistrySearch Id="CheckIISMetabase" Root="HKLM" Key="SOFTWARE\Microsoft\InetStp\Components" Name="ADSICompatibility" Type="raw" />
</Property>

<Condition Message="IIS 6 Metabase Compatibility feature must be installed">
    Installed OR ((VersionNT &lt; 600) OR IIS_METABASE_COMPAT)
</Condition>

34

सभी आईडी को अलग-अलग नाम स्थान पर रखें

  • विशेषताएं F. उदाहरण के साथ शुरू होती हैं : F.Documentation, F.Binaries, F.SampleCode।
  • घटक C. पूर्व से शुरू होते हैं : सी। कैमफाइल, सी। आरलीनोट्स, सी। लिसेन्सफाइल, सी। आईनीफाइल, सी। रीजेंसी।
  • CustomActions CA. Ex हैं: CA.LaunchHelp, CA.UpdateReadyDlg, CA.SetPropertyX
  • फाइलें हैं Fi.
  • निर्देशिकाएँ हैं Di.
  • और इसी तरह।

मुझे लगता है कि यह सभी विभिन्न श्रेणियों में सभी विभिन्न आईडी का ट्रैक रखने में काफी मदद करता है।


मैं नामस्थान का उपयोग नहीं करता हूं, लेकिन मैं आईडी जोड़ता हूं; उदाहरण के लिए: उदाहरणविशेषज्ञ, ChmFileComponent। मुझे लगता है कि मुझे टाइपिंग बहुत पसंद है ;-)
DVDvorle

25

विलक्षण प्रश्न। मुझे दिखाई गई कुछ सर्वोत्तम प्रथाओं को देखना अच्छा लगेगा।

मुझे बहुत सी फाइलें मिली हैं जो मैं वितरित करता हूं, इसलिए मैंने अपनी परियोजना को कई wxs स्रोत फ़ाइलों में सेट किया है।

मेरे पास एक शीर्ष स्तरीय स्रोत फ़ाइल है जिसे मैं Product.wx कहता हूं जिसमें मूल रूप से स्थापना के लिए संरचना शामिल है, लेकिन वास्तविक घटक नहीं। इस फ़ाइल में कई खंड हैं:

<Product ...>
  <Package ...>
    <Media>... 
   <Condition>s ...
   <Upgrade ..>
   <Directory> 
        ...
   </Directory>
   <Feature>
      <ComponentGroupRef ... > A bunch of these that
   </Feature>
   <UI ...>
   <Property...>
   <Custom Actions...>
   <Install Sequences....
  </Package>
</Product>

.Wix की बाकी फाइलें Fragments से बनी होती हैं, जिसमें ComponentGroups होते हैं जो Product.wxs में फ़ीचर टैग में संदर्भित होते हैं। मेरी परियोजना में फ़ाइलों का एक अच्छा तार्किक समूहन है जो मैं वितरित करता हूं

<Fragment>
   <ComponentGroup>
     <ComponentRef>
     ....
    </ComponentGroup>
    <DirectoryRef>
      <Component... for each file
      .... 
    </DirectoryRef>
</Fragment>

यह सही नहीं है, मेरी OO मकड़ी का भाव थोड़ा झुनझुनाहट करता है क्योंकि टुकड़े को Product.wxs फ़ाइल (उदा DirectoryRef) में नामों का संदर्भ देना होता है, लेकिन मुझे लगता है कि एक बड़े स्रोत फ़ाइल को बनाए रखना आसान है।

मुझे इस पर टिप्पणियाँ सुनना अच्छा लगेगा, या यदि किसी के पास कोई अच्छा सुझाव भी है!


हमारा सेटअप भी इस दृष्टिकोण के समान है। यह अच्छा है क्योंकि हम विभिन्न उत्पादों के लिए अपने आधार सेटअप के रूप में Products.wxs के बराबर का उपयोग कर सकते हैं।
si618

@ पेटर टेट: आपका मकड़ी का भाव सही है। निर्देशिका एलियासिंग के बारे में मेरा जवाब देखें।
विम कॉइनन

मैं एक ही दृष्टिकोण लेता हूं: लेआउट के साथ Product.wx स्थिर है, और एक बिल्ड टास्क (heat.exe) मेरे Content.wxs फ़ाइल को उत्पन्न करता है
timvw

20

ऐप या हेल्पफाइल लॉन्च करने के लिए एक्जिट डायलॉग में एक चेकबॉक्स जोड़ें।

...

<!-- CA to launch the exe after install -->
<CustomAction Id          ="CA.StartAppOnExit"
              FileKey     ="YourAppExeId"
              ExeCommand  =""
              Execute     ="immediate"
              Impersonate ="yes"
              Return      ="asyncNoWait" />

<!-- CA to launch the help file -->
<CustomAction Id         ="CA.LaunchHelp"
              Directory  ="INSTALLDIR"
              ExeCommand ='[WindowsFolder]hh.exe IirfGuide.chm'
              Execute    ="immediate"
              Return     ="asyncNoWait" />

<Property Id="WIXUI_EXITDIALOGOPTIONALCHECKBOXTEXT"
          Value="Launch MyApp when setup exits." />

<UI>
  <Publish Dialog  ="ExitDialog"
           Control ="Finish"
           Order   ="1"
           Event   ="DoAction"
           Value   ="CA.StartAppOnExit">WIXUI_EXITDIALOGOPTIONALCHECKBOXTEXT</Publish>
</UI>

यदि आप इसे इस तरह से करते हैं, तो "मानक" उपस्थिति बिल्कुल सही नहीं है। चेकबॉक्स हमेशा एक ग्रे बैकग्राउंड होता है, जबकि संवाद सफेद होता है:

alt text http://www.dizzymonkeydesign.com/blog/misc/adding-and-customizing-dlgs-in-wix-3/images/exit_dlg_1.gif

इसके आस-पास का एक तरीका यह है कि आप अपने स्वयं के कस्टम ExitDialog को अलग-अलग स्थित चेकबॉक्स के साथ निर्दिष्ट करें । यह काम करता है, लेकिन सिर्फ एक नियंत्रण का रंग बदलने के लिए बहुत काम की तरह लगता है। उसी चीज़ को हल करने का एक और तरीका यह है कि उस विशेष बॉक्सबॉक्स नियंत्रण के लिए नियंत्रण तालिका में X, Y फ़ील्ड को बदलने के लिए उत्पन्न MSI को पोस्ट-प्रोसेस करना है। जावास्क्रिप्ट कोड इस तरह दिखता है:

var msiOpenDatabaseModeTransact = 1;
var filespec = WScript.Arguments(0);
var installer = new ActiveXObject("WindowsInstaller.Installer");
var database = installer.OpenDatabase(filespec, msiOpenDatabaseModeTransact);
var sql = "UPDATE `Control` SET `Control`.`Height` = '18', `Control`.`Width` = '170'," +
          " `Control`.`Y`='243', `Control`.`X`='10' " +
          "WHERE `Control`.`Dialog_`='ExitDialog' AND " + 
          "  `Control`.`Control`='OptionalCheckBox'";
var view = database.OpenView(sql);
view.Execute();
view.Close();
database.Commit();

MSI के उत्पन्न होने के बाद (code.exe) का उपयोग करके एक कमांड-लाइन स्क्रिप्ट (cscript.exe का उपयोग करके) के रूप में इस कोड को चलाना एक ExitDialog का उत्पादन करेगा जो अधिक पेशेवर दिखता है:

alt text http://www.dizzymonkeydesign.com/blog/misc/adding-and-customizing-dlgs-in-wix-3/images/exit_dlg_2.gif


हा! मेरा ब्लॉग नहीं। मैंने भी इसे पढ़ा। और मेरे पास ऊपर पाठ में ब्लॉग प्रविष्टि के लिए एक लिंक है। लेकिन उन्होंने इसे मेरे मुकाबले अलग तरह से किया। मुझे अपना तरीका बेहतर लगता है !!
चीजो

1
Js के लिए धन्यवाद, बहुत मददगार! एक बात है कि मैं wxs में परिवर्तन करना पड़ा की जगह है WIXUI_EXITDIALOGOPTIONALCHECKBOXके साथ WIXUI_EXITDIALOGOPTIONALCHECKBOX = 1 and NOT Installedअंदर<Publish>
अलेक्जेंडर Kojevnikov

क्या डिफ़ॉल्ट रूप से चेक बॉक्स बनाने का कोई तरीका है?
एविसी डेविस

डिफॉल्ट रूप से बॉक्स को जांचने के लिए, मैंने इसका इस्तेमाल किया: <संपत्ति आईडी = "WIXUI_EXITDIALOGOPTIONALCHECKBOX" मान = "1" />
डेविस डेविस

एक निफ्टी समाधान की तरह लगता है, लेकिन मैं इसे कैसे उपयोग करूं? मेरे wixproj में <AfterBuild> तत्व के अंदर js लगाने का कोई तरीका है? या जब से आप इसे कमांड लाइन से चलाने का संदर्भ देते हैं, क्या यह पोस्ट-बिल्ड इवेंट के रूप में बेहतर है, इस मामले में, विंडोज के लिए एक अच्छा जेएस कमांड-लाइन दुभाषिया क्या है?
वैनमेले

18

एक ही स्रोत फ़ाइलों का उपयोग करके लाइव, टेस्ट, प्रशिक्षण, ... संस्करण बनाना।

संक्षेप में: प्रत्येक इंस्टॉलर के लिए अद्वितीय अपग्रेडकोड ​​बनाएं और प्रत्येक इंस्टॉलर के लिए प्रत्येक गाइड के पहले चरित्र को स्वचालित रूप से परिभाषित करें, शेष 31 को अद्वितीय छोड़ दें।

आवश्यक शर्तें

मान्यताओं

  • WiX चर का उपयोग UpgradCode, ProductName, InstallName को परिभाषित करने के लिए किया जाता है।
  • आपके पास पहले से ही एक काम करने वाला इंस्टॉलर है। जब तक आप ऐसा नहीं करेंगे मैं यह कोशिश नहीं करूंगा।
  • आपके सभी अवयव एक फ़ाइल (Components.wxs) में रखे गए हैं। यदि आपके पास एक से अधिक फ़ाइलें हैं, तो यह प्रक्रिया काम करेगी, बस करने के लिए अधिक काम करना होगा।

निर्देशिका संरचना

  • Setup.Library
    • सभी wxs फ़ाइलें (घटक, सुविधाएँ, UI संवाद, ...)
    • Common.Config.wxi (ProductCode = "*", ProductVersion, PlatformProgramFilesFolder, ...)
  • Setup.Live (wixproj)
    • सभी सेटअप को लिंक करें। "मौजूदा फ़ाइल जोड़ें" -> "लिंक के रूप में जोड़ें" का उपयोग करके फ़ाइलें (दृश्य स्टूडियो में जोड़ें बटन के ठीक नीचे तीर बटन)
    • Config.wxi (यूनिक अपग्रेडकोड, प्रोडक्टनेम, इंस्टालनाम, ...)
  • Setup.Test , ...
    • लाइव के अनुसार, लेकिन config.wxi टेस्ट वातावरण के लिए कॉन्फ़िगर किया गया है।

प्रक्रिया

  • Setup.Library निर्देशिका बनाएँ और मौजूदा प्रोजेक्ट से अपने सभी wxs और wxi फ़ाइलों (config.wxi को छोड़कर) को स्थानांतरित करें।
  • सामान्य wixproj के अनुसार Setup.Live, Setup.Test आदि बनाएँ।
  • पहले Setup.Live में wixproj में पहले लक्ष्य को जोड़ें, आदि के लिए MSBuild कम्युनिटी टास्क FileUpdate को संशोधित करने के लिए Guids को संशोधित करने के लिए (मैं प्रशिक्षण के लिए लाइव, बी के लिए ए और प्रशिक्षण के लिए सी का इस्तेमाल किया)
  • अवयवों को वापस करने के लिए AfterBuild लक्ष्य जोड़ें। 0 में वापस गाइड।
  • ओर्का के साथ सत्यापित करें कि प्रत्येक MSI में प्रत्येक घटक में संशोधित मार्गदर्शिका है।
  • सत्यापित करें कि मूल छापे बहाल हैं।
  • सत्यापित करें कि प्रत्येक MSI सही उत्पाद और स्थान स्थापित कर रहा है (और अपग्रेड कर रहा है)।

उदाहरण config.wxi

<?xml version="1.0" encoding="utf-8"?>
<Include>
<!-- Upgrade code should not change unless you want to install 
     a new product and have the old product remain installed, 
     that is, both products existing as separate instances. -->
<?define UpgradeCode = "YOUR-GUID-HERE" ?>

<!-- Platform specific variables -->
<?if $(var.Platform) = x64 ?>
  <!-- Product name as you want it to appear in Add/Remove Programs-->
  <?define ProductName = "Foo 64 Bit [Live]" ?>
<?else ?>
  <?define ProductName =  "Foo [Live]" ?>
<?endif ?>

<!-- Directory name used as default installation location -->
<?define InstallName = "Foo [Live]" ?>

<!-- Registry key name used to store installation location -->
<?define InstallNameKey = "FooLive" ?>

<?define VDirName = "FooLive" ?>
<?define AppPoolName = "FooLiveAppPool" ?>
<?define DbName = "BlahBlahLive" ?>
</Include>

उदाहरण config.Common.wxi

<?xml version="1.0" encoding="utf-8"?>
<Include>
<!-- Auto-generate ProductCode for each build, release and upgrade -->
<?define ProductCode = "*" ?>

<!-- Note that 4th version (Revision) is ignored by Windows Installer -->
<?define ProductVersion = "1.0.0.0" ?>

<!-- Minimum version supported if product already installed and this is an upgrade -->
<!-- Note that 4th version (Revision) is ignored by Windows Installer -->
<?define MinimumUpgradeVersion = "0.0.0.0" ?>

<!-- Platform specific variables -->
<?if $(var.Platform) = x64 ?>
   <?define Win64 = "yes" ?>
   <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else ?>
   <?define Win64 = "no" ?>
   <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif ?>

<?define ProductManufacturer = "Foo Technologies"?>

<!-- Decimal Language ID (LCID) for the Product. Used for localization. -->
<?define ProductLanguage = "1033" ?>

<?define WebSiteName = "DefaultWebSite" ?>
<?define WebSitePort = "80" ?>

<?define DbServer = "(local)" ?>
</Include>

उदाहरण Components.wxs

<?xml version="1.0" encoding="utf-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <!-- The pre-processor variable which allows the magic to happen :) -->
  <?include $(sys.CURRENTDIR)\Config.wxi?>
  <?include ..\Setup.Library\Config.Common.wxi?>
  <Fragment Id="ComponentsFragment">
    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="$(var.PlatformProgramFilesFolder)">
        <Directory Id="INSTALLLOCATION" Name="$(var.InstallName)">
          <Component Id="ProductComponent" Guid="0XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" KeyPath="yes">
          ...

नोट: मैं अब घटक के बाहर गाइड विशेषता (बराबर *) को छोड़ने का सुझाव दूंगा , प्रति घटक एक फाइल का उपयोग करके और फाइल को कीथ के रूप में सेट करने का। यह नीचे दिखाए गए कॉलिंग ModifyComponentsGuidsऔर RevertComponentsGuidsलक्ष्य की आवश्यकता को हटा देता है । यह आपके सभी घटकों के लिए संभव नहीं हो सकता है।

उदाहरण सेटअप ।Live.wixproj

<Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" />
<Target Name="BeforeBuild">
  <CallTarget Targets="ModifyComponentsGuids" />
</Target>
<Target Name="AfterBuild">
  <CallTarget Targets="RevertComponentsGuids" />
</Target>
<!-- Modify the first character of every Guid to create unique value for Live, Test and Training builds -->
<Target Name="ModifyComponentsGuids">
  <FileUpdate Files="..\Setup.Library\Components.wxs" Regex="Guid=&quot;([a-f]|[A-F]|\d)" ReplacementText="Guid=&quot;A" />
</Target>
<!-- Revert the first character of every Guid back to initial value -->
<Target Name="RevertComponentsGuids">
  <FileUpdate Files="..\Setup.Library\Components.wxs" Regex="Guid=&quot;([a-f]|[A-F]|\d)" ReplacementText="Guid=&quot;0" />
</Target>

अंतिम विचार

  • यह प्रक्रिया एक ही इंस्टॉलर के लिए अलग-अलग मर्ज मॉड्यूल (लाइव, टेस्ट, ... सुविधाओं के रूप में) के लिए अलग-अलग इंस्टॉलर बनाने के लिए भी काम करना चाहिए। मैं अलग-अलग इंस्टॉलरों के साथ चला गया क्योंकि यह एक सुरक्षित विकल्प लग रहा था, अधिक जोखिम है कि कोई व्यक्ति प्रशिक्षण के बजाय लाइव को अपग्रेड कर सकता है यदि वे एक ही बॉक्स पर हैं और आप विभिन्न मर्ज मॉड्यूल के लिए सुविधाओं का उपयोग करते हैं।
  • यदि आप अपने MSI का उपयोग अपग्रेड करने के साथ-साथ नए इंस्टॉलेशन अर्थात प्रमुख अपग्रेड के लिए भी करते हैं, और आप रजिस्ट्री में अपने इंस्टॉलेशन स्थान को सहेजते हैं, तो प्रत्येक इंस्टॉल के लिए कुंजी नाम के लिए एक वैरिएबल बनाना याद रखें।
  • हम प्रत्येक इंस्टॉलर के लिए अद्वितीय वर्चुअल निर्देशिका नाम, एप्लिकेशन पूल, डेटाबेस नाम, एट वगैरह को सक्षम करने के लिए प्रत्येक config.wxi में चर भी बनाते हैं।

अद्यतन 1: ऑटो-जेनरेट करने वाला कंपोनेंट गिड्स फाइलपपडेट कार्य को करने की आवश्यकता को हटाता है यदि आप प्रत्येक फाइल के लिए गाइड = "*" के साथ कम्पोनेंट के रूप में फाइल सेट करते हैं।

अद्यतन 2: हम जिन मुद्दों के खिलाफ आए हैं उनमें से एक यह है कि यदि आप अपने घटक के दिशानिर्देशों को ऑटो-जेनरेट नहीं करते हैं और बिल्ड विफल हो जाता है, तो अस्थायी फ़ाइलों को मैन्युअल रूप से हटाने की आवश्यकता होती है।

अद्यतन 3: svn पर निर्भरता को हटाने का एक तरीका मिला: बाहरी और अस्थायी फ़ाइल निर्माण। यह बिल्ड प्रक्रिया को अधिक लचीला बनाता है (और यदि आप अपने दोस्तों को वाइल्डकार्ड नहीं कर सकते हैं तो सबसे अच्छा विकल्प है) और कम भंगुर है अगर प्रकाश या मोमबत्ती में कोई विफलता है।

अद्यतन 4: उदाहरण के रूपांतरों का उपयोग कर कई उदाहरणों के लिए समर्थन वाईएक्स 3.0+ में है, निश्चित रूप से देखने लायक भी है।


MSBuild सामुदायिक कार्य संदर्भ के लिए +1, उस पैकेज से प्यार करें
BozoJoe

17

Msi डायग्नोस्टिक लॉगिंग का उपयोग विस्तृत विफलता की जानकारी प्राप्त करने के लिए

msiexec /i Package.msi /l*v c:\Package.log

कहाँ पे

Package.msi
आपके पैकेज का नाम है और
c: \ Package.log
वह जगह है जहाँ आप लॉग का आउटपुट चाहते हैं

Msi त्रुटि कोड

विक्स इंट्रो वीडियो
ओह और रैंडम विक्स इंट्रो वीडियो जिसमें "मिस्टर वाईएक्स" रोब मेन्चिंग "वैचारिक बड़ी तस्वीर" सहायक है।


2
+1 बेहतर होगा यदि हम कमांड लाइन के बजाय विक्स के भीतर से लॉगिंग को सक्षम कर सकें।
si618

3
वाईएक्स करता है। MsiLogging गुण सेट करें। केवल Windows इंस्टालर 4.0+ द्वारा समर्थित है।
रोब मेन्शचिंग

आपका बहुत बहुत धन्यवाद "मिस्टर विक्स"। होगा कि बाहर की जाँच करें।
टेरेंस

17

जावास्क्रिप्ट CustomActions का उपयोग करें क्योंकि वे आसान soooo हैं

लोगों ने कहा है कि MSI CustomActions के लिए जावास्क्रिप्ट का उपयोग करना गलत बात है । दिए गए कारण: कठिन डिबग करने के लिए, इसे विश्वसनीय बनाने के लिए कठिन है। मैं सहमत नहीं हूँ। यह डीबग करना मुश्किल नहीं है, निश्चित रूप से सी ++ की तुलना में कठिन नहीं है। इसकी बस अलग है। मैंने जावास्क्रिप्ट में CustomActions को C ++ का उपयोग करने की तुलना में सुपर आसान, बहुत आसान लिखा है। काफी तेज। और बस के रूप में विश्वसनीय है।

बस एक खामी है: जावास्क्रिप्ट कस्टमएक्शंस को ओर्का के माध्यम से निकाला जा सकता है, जबकि सी / सी ++ सीए को रिवर्स-इंजीनियरिंग की आवश्यकता होगी। यदि आप अपने इंस्टॉलर मैजिक को संरक्षित बौद्धिक संपदा मानते हैं, तो आप स्क्रिप्ट से बचना चाहेंगे।

यदि आप स्क्रिप्ट का उपयोग करते हैं, तो आपको बस कुछ संरचना के साथ शुरुआत करने की आवश्यकता है। यहाँ कुछ आप शुरू करने के लिए है।


CustomAction के लिए जावास्क्रिप्ट "बॉयलरप्लेट" कोड:

//
// CustomActions.js 
// 
// Template for WIX Custom Actions written in Javascript.
// 
// 
// Mon, 23 Nov 2009  10:54
// 
// ===================================================================


// http://msdn.microsoft.com/en-us/library/sfw6660x(VS.85).aspx
var Buttons = {
        OkOnly           : 0,
        OkCancel         : 1,
        AbortRetryIgnore : 2,
        YesNoCancel      : 3
};

var Icons = {
        Critical         : 16,
        Question         : 32,
        Exclamation      : 48,
        Information      : 64
};

var MsgKind = {
        Error            : 0x01000000,
        Warning          : 0x02000000,
        User             : 0x03000000,
        Log              : 0x04000000
};

// http://msdn.microsoft.com/en-us/library/aa371254(VS.85).aspx
var MsiActionStatus = {
        None             : 0,
        Ok               : 1, // success
        Cancel           : 2,
        Abort            : 3,
        Retry            : 4, // aka suspend?
        Ignore           : 5  // skip remaining actions; this is not an error.
};


function MyCustomActionInJavascript_CA() {
    try {
        LogMessage("Hello from MyCustomActionInJavascript");
        // ...do work here...
        LogMessage("Goodbye from MyCustomActionInJavascript");
    }
    catch (exc1) {
        Session.Property("CA_EXCEPTION") = exc1.message ;
        LogException(exc1);
        return MsiActionStatus.Abort;
    }
    return MsiActionStatus.Ok;
}

// Pop a message box.  also spool a message into the MSI log, if it is enabled. 
function LogException(exc) {
    var record = Session.Installer.CreateRecord(0);
    record.StringData(0) = "CustomAction: Exception: 0x" + decimalToHexString(exc.number) + " : " + exc.message;
    Session.Message(MsgKind.Error + Icons.Critical + Buttons.btnOkOnly, record);
}


// spool an informational message into the MSI log, if it is enabled. 
function LogMessage(msg) {
    var record = Session.Installer.CreateRecord(0);
    record.StringData(0) = "CustomAction:: " + msg;
    Session.Message(MsgKind.Log, record);
}


// http://msdn.microsoft.com/en-us/library/d5fk67ky(VS.85).aspx
var WindowStyle = {
    Hidden : 0,
    Minimized : 1,
    Maximized : 2
};

// http://msdn.microsoft.com/en-us/library/314cz14s(v=VS.85).aspx
var OpenMode = {
    ForReading : 1,
    ForWriting : 2,
    ForAppending : 8
};

// http://msdn.microsoft.com/en-us/library/a72y2t1c(v=VS.85).aspx
var SpecialFolders = {
    WindowsFolder : 0, 
    SystemFolder :  1, 
    TemporaryFolder : 2
};

// Run a command via cmd.exe from within the MSI
function RunCmd(command)
{
    var wshell = new ActiveXObject("WScript.Shell");
    var fso = new ActiveXObject("Scripting.FileSystemObject");
    var tmpdir = fso.GetSpecialFolder(SpecialFolders.TemporaryFolder);
    var tmpFileName = fso.BuildPath(tmpdir, fso.GetTempName());

    LogMessage("shell.Run("+command+")");

    // use cmd.exe to redirect the output
    var rc = wshell.Run("%comspec% /c " + command + "> " + tmpFileName, WindowStyle.Hidden, true);
    LogMessage("shell.Run rc = "  + rc);

    // here, optionally parse the output of the command 
    if (parseOutput) {
        var textStream = fso.OpenTextFile(tmpFileName, OpenMode.ForReading);
        while (!textStream.AtEndOfStream) {
            var oneLine = textStream.ReadLine();
            var line = ParseOneLine(oneLine);
                ...
        }
        textStream.Close();
    }

    if (deleteOutput) {
        fso.DeleteFile(tmpFileName);
    }

    return {
        rc : rc,
        outputfile : (deleteOutput) ? null : tmpFileName
    };
}

फिर, कस्टम क्रिया को कुछ इस तरह से पंजीकृत करें:

<Fragment>
  <Binary Id="IisScript_CA" SourceFile="CustomActions.js" />

  <CustomAction Id="CA.MyCustomAction"
              BinaryKey="IisScript_CA"
              JScriptCall="MyCustomActionInJavascript_CA"
              Execute="immediate"
              Return="check" />
</Fragmemt>

आप निश्चित रूप से, कई कस्टम क्रियाओं के लिए जितने चाहें उतने जावास्क्रिप्ट फ़ंक्शंस सम्मिलित कर सकते हैं। एक उदाहरण: मैंने मौजूदा वेबसाइटों की एक सूची प्राप्त करने के लिए, IIS पर एक WMI क्वेरी करने के लिए जावास्क्रिप्ट का उपयोग किया, जिसके लिए एक ISAPI फ़िल्टर स्थापित किया जा सकता है। इस सूची का उपयोग बाद में UI अनुक्रम में दिखाए गए एक सूची बॉक्स को पॉप्युलेट करने के लिए किया गया था। सब बहुत आसान है।

IIS7 पर, IIS के लिए कोई WMI प्रदाता नहीं है, इसलिए मैंने shell.Run()कार्य करने के लिए appcmd.exe को लागू करने के लिए दृष्टिकोण का उपयोग किया । आसान।

संबंधित प्रश्न: जावास्क्रिप्ट कस्टमएक्शंस के बारे में


2
+1, मुझे आसानी से सेटअप करने के लिए डीटीएफ दृष्टिकोण मिल जाता है, लेकिन जावास्क्रिप्ट भी उपयोगी हो सकता है।
si618

12

पीटर टेट ने पहले ही दिखाया है कि आप अलग-अलग विक्स अंशों में पुन: प्रयोज्य कंपोनेंटग्रुप परिभाषाओं को कैसे परिभाषित कर सकते हैं। इससे जुड़े कुछ अतिरिक्त टोटके:

निर्देशिका अलियासिंग

घटक समूह के टुकड़े को मुख्य उत्पाद wxs द्वारा परिभाषित निर्देशिकाओं के बारे में जानने की आवश्यकता नहीं है। आपके घटक समूह के टुकड़े में आप इस तरह एक फ़ोल्डर के बारे में बात कर सकते हैं:

<DirectoryRef Id="component1InstallFolder">
...
</DirectoryRef>

फिर मुख्य उत्पाद इस तरह से अपनी एक निर्देशिका (जैसे "productInstallFolder") को उर्फ ​​कर सकते हैं:

<Directory Id="productInstallFolder" Name="ProductName">
   <!-- not subfolders (because no Name attribute) but aliases for parent! -->
   <Directory Id="component1InstallFolder"/> 
   <Directory Id="component2InstallFolder"/> 
</Directory>

निर्भरता ग्राफ

घटक घटक में घटक घटक समूह बाल तत्व शामिल हो सकते हैं। यह बहुत अच्छा है यदि आपके पास उनके बीच एक जटिल निर्भरता ग्राफ के साथ पुन: प्रयोज्य घटकों का एक बड़ा पूल है। आप बस प्रत्येक घटक के लिए अपने स्वयं के टुकड़े में एक ComponentGroup सेट अप करें और इस तरह निर्भरता की घोषणा करें:

<ComponentGroup Id="B">
   <ComponentRef Id="_B" />
   <ComponentGroupRef Id="A">
</ComponentGroup>

यदि आप अब अपने सेटअप में घटक समूह "बी" का संदर्भ देते हैं क्योंकि यह आपके आवेदन की प्रत्यक्ष निर्भरता है, तो यह स्वचालित रूप से घटक समूह "ए" में खींच लेगा, भले ही आवेदन लेखक को कभी भी यह एहसास न हो कि यह "बी" की निर्भरता थी। यह "बस काम करता है" जब तक आपके पास कोई परिपत्र निर्भरता नहीं है।

पुन: प्रयोज्य विक्सलिब

उपरोक्त निर्भरता ग्राफ विचार सबसे अच्छा काम करता है यदि आप lit.exe के साथ पुन: प्रयोज्य wixlib में बड़े-पूल-ओ-पुन: प्रयोज्य-घटकों को संकलित करते हैं। एप्लिकेशन सेटअप बनाते समय, आप इस wixlib को wixobj फ़ाइल की तरह संदर्भित कर सकते हैं। Cand.exe लिंकर स्वचालित रूप से किसी भी टुकड़े को समाप्त कर देगा जो मुख्य उत्पाद wxs फ़ाइल (ओं) द्वारा "खींचा नहीं" जाता है।


12

मुझे आश्चर्य है कि निर्माण के दौरान WXS फ़ाइल बनाने के लिए किसी ने भी T4 का उपयोग करने का उल्लेख नहीं किया है। मुझे हेनरी ली @ न्यू एज सॉल्यूशंस के माध्यम से इस बारे में पता चला ।

अनिवार्य रूप से, आप एक T4 टेम्पलेट को निष्पादित करने के लिए एक कस्टम MSBuild कार्य बनाते हैं, और वह टेम्पलेट WXS को Wix प्रोजेक्ट संकलित होने से ठीक पहले आउटपुट करता है। यह आपको किसी अन्य समाधान को संकलित करने से स्वचालित रूप से सभी असेंबली आउटपुट शामिल करने पर निर्भर करता है (जिसका अर्थ है कि अब आपको कभी भी नई असेंबली जोड़ने के लिए wxs को संपादित करने की आवश्यकता नहीं है)।


2
+1 यह वास्तव में अच्छा है, मैं असेंबली के बारे में इतना चिंतित नहीं हूं, लेकिन हमारी वेब परियोजनाओं में एस्पेक्स पेज और अन्य कलाकृतियों (चित्र, सीएसएस) के साथ समस्या हो सकती है जो परियोजना में जोड़े गए हैं लेकिन वाईएक्स नहीं।
si618

4
भविष्य के आगंतुकों के लिए, Wix 3.5 में एक उपयोगिता heat.exe है जो इस कटाई को स्वचालित रूप से करता है
Mrchief

@ माचिस - मुझे विश्वास नहीं होता कि हीट संदर्भित संदर्भित असेंबलियों को उठाता है जो स्थानीय नकल की जाती हैं - यह स्पष्ट रूप से 4.0 के लिए योजनाबद्ध है। संदर्भ: sourceforge.net/tracker/…
पीटर टी। लाकॉम्ब जूनियर

हीट संदर्भित विधानसभाओं को नहीं उठाता है।
टोफुटिम

W4S फ़ाइल उत्पन्न करने के लिए T4 का उपयोग करने के कुछ अच्छे उदाहरण क्या हैं?
टोफुटिम

12

फेस को स्मैश करने के लिए Heat.exe का उपयोग करना और दर्द वाले बड़े इंस्टॉल्स पर "एपिक Pwnage" को उड़ाना

गर्मी के बारे में सी और रॉबर्ट-पी के उत्तरों पर विस्तार ।

अनुवाद: (गर्मी का उपयोग करके परियोजना में व्यक्तिगत फ़ाइलों को टाइप करने से बचने के लिए और समग्र आसान प्रक्रिया के लिए बिल्ड को स्वचालित करने के लिए।)

वाईएक्स 2.0 हीट सिंटैक्स विस्तृत।

नए संस्करणों के लिए (सभी पुराने संस्करणों से भिन्न नहीं हैं, लेकिन संभावित रूप से कष्टप्रद वाक्यविन्यास परिवर्तन हैं ...) निर्देशिका पर जाएं हीट cmd.exe से है और बस गर्मी में टाइप करें, लेकिन मेरे पास मदद के लिए यहां एक उदाहरण है यदि आवश्यक हो तो नए संस्करणों के साथ।

दृश्य स्टूडियो 2010 में अपने बिल्ड इवेंट में निम्न जोड़ना।
(राइट क्लिक प्रोजेक्ट-> गुण -> बिल्ड इवेंट-> प्री-बिल्ड इवेंट)

$(WIX)bin\heat.exe" dir "$(EnviromentVariable)" -cg GroupVariable -gg -scom -sreg -sfrag - srd -dr INSTALLLOCATION -var env.LogicPath -out "$(FragmentDir)\FileName.wxs

-gg 

जब गर्मी चलती है तो गाइड्स उत्पन्न करता है (जैसे कि जब आप ऊपर दिए गए कमांड को निष्पादित करते हैं)

-scom 

"COM फ़ाइलें" न लें

-sreg 

न करें "रजिस्ट्री फ़ाइलें"

-sfrag 

न पकड़ें "टुकड़े"

-srd 

"रूट डिर" को न पकड़ो

dir

dir इंगित करता है कि आप हीट को किसी फ़ोल्डर में देखना चाहते हैं

"$ (EnviromentVariable)"

उस चर का नाम जिसे आप प्रीप्रोसेसर वेरिएबल्स में जोड़ेंगे (राइट क्लिक प्रोजेक्ट, प्रॉपर्टीज पर जाएं) प्रोजेक्ट प्रॉपर्टीज-> सेक्शन बनाएं जहां यह कहता है कि प्रीप्रोसेसर वेरिएबल्स को परिभाषित करें (विजुअल स्टूडियो 2010 को मानता है)

उदाहरण:
EnviromentVariable = C: \ परियोजना \ बिन \ डीबग;
कोई दोहरे उद्धरण नहीं बल्कि एक अर्धविराम के साथ समाप्त होता है

-सीजी ग्रुपवीरेबल 

घटक घटक जो मुख्य wxs फ़ाइल के लिए बनाए गए टुकड़े से संदर्भित किया जाएगा

FragmentDir

खंड निर्देशिका जहां आउटपुट wxs टुकड़ा संग्रहीत किया जाएगा

FileName.wxs

फ़ाइल का नाम

पूर्ण ट्यूटोरियल यहाँ, इसलिए उपयोगी freakin

भाग १ भाग २


थोड़ा अलग उद्देश्यों के लिए एक और उपयोगी उपकरण है: पैराफिन ( wintellect.com/CS/blogs/jrobbins/archive/2010/03/10/4107.aspx )
ralf.w.

9

COM ऑब्जेक्ट सहित:

heatसभी के लिए (यदि सभी नहीं) रजिस्ट्री प्रविष्टियों और उनके लिए आवश्यक अन्य कॉन्फ़िगरेशन उत्पन्न करता है। ख़ुश हो जाओ!

प्रबंधित COM ऑब्जेक्ट (उर्फ, .NET या C # COM ऑब्जेक्ट) सहित

heatप्रबंधित COM ऑब्जेक्ट का उपयोग करने से आपको लगभग पूर्ण विक्स दस्तावेज़ मिल जाएगा।

यदि आपको GAC में उपलब्ध पुस्तकालय की आवश्यकता नहीं है (अर्थात, विश्व स्तर पर उपलब्ध है: उस समय का MOST जिसकी आपको अपने .NET असेंबली के साथ वैसे भी ज़रूरत नहीं है - आपने शायद इस बिंदु पर कुछ गलत किया है, यदि इसका इरादा नहीं है एक साझा पुस्तकालय) आप CodeBaseरजिस्ट्री कुंजी को सेट करने के लिए अद्यतन करना सुनिश्चित करना चाहेंगे [#ComponentName]। यदि आप इसे GAC पर स्थापित करने की योजना बना रहे हैं (उदाहरण के लिए, आपने कुछ नई भयानक लाइब्रेरी बनाई है, जिसका उपयोग हर कोई करना चाहेगा) तो आपको इस प्रविष्टि को हटाना होगा, और Fileतत्व में दो नई विशेषताओं को जोड़ना होगा : Assemblyऔर KeyPath। असेंबली को ".net" पर KeyPathसेट किया जाना चाहिए और "हां" पर सेट किया जाना चाहिए।

हालांकि, कुछ वातावरण (विशेष रूप से प्रबंधित मेमोरी जैसे स्क्रिप्टिंग भाषाओं के साथ कुछ भी) को टाइपिब के साथ-साथ एक्सेस की आवश्यकता होगी। अपने टाइपिबेल पर चलना सुनिश्चित करेंheat और इसे शामिल करें। heatसभी आवश्यक रजिस्ट्री कुंजी उत्पन्न करेगा। कितना मजेदार था वो?


8

को स्थापित कर रहा है C:\ProductName

कुछ अनुप्रयोगों को C:\ProductNameया कुछ इसी तरह स्थापित करने की आवश्यकता है , लेकिन नेट में 99.9% (यदि 100% नहीं है)C:\Program Files\CompanyName\ProductName

निम्नलिखित कोड का उपयोग ड्राइव TARGETDIRकी जड़ में संपत्ति सेट करने के लिए किया जा सकता है C:( वाईएक्स-उपयोगकर्ता सूची से लिया गया ):

<CustomAction Id="AssignTargetDir" Property="TARGETDIR" Value="C:\" Execute="firstSequence" />
<InstallUISequence>
    <Custom Action="AssignTargetDir" Before="CostInitialize">TARGETDIR=""</Custom>
</InstallUISequence>
<InstallExecuteSequence>
    <Custom Action="AssignTargetDir" Before="CostInitialize">TARGETDIR=""</Custom>
</InstallExecuteSequence>

नोट: डिफ़ॉल्ट रूप से, इंगित TARGETDIR नहीं करता है C:\! इसके बजाय यह इंगित करता है ROOTDRIVEकि बदले में सबसे मुक्त स्थान के साथ ड्राइव की जड़ को कैसे देखें ( यहां देखें ) - और यह जरूरी नहीं हैC: ड्राइव है। एक और हार्ड ड्राइव, विभाजन, या USB ड्राइव हो सकता है!

फिर, आपके <Product ...>टैग के नीचे , आपको हमेशा की तरह निम्न निर्देशिका टैग की आवश्यकता होती है:

<Directory Id="TARGETDIR" Name="SourceDir">
    <Directory Id="APPLICATIONFOLDER" Name="$(var.ProductName)">
        <!-- your content goes here... -->
    </Directory>
</Directory>

यह सिर्फ स्थापित करने के लिए आसान नहीं होगा WindowsVolume?
विम कोएन

1
हां, लेकिन आपको वर्कअराउंड का उपयोग करना होगा क्योंकि WindowsVolumeसंपत्ति का उपयोग एक के रूप में नहीं किया जा सकता है Directory(कंपाइलर एक त्रुटि / चेतावनी देता है), जैसा कि यहां और यहां बताया गया है । व्यक्तिगत रूप से, मुझे लगता है कि वर्कअराउंड भ्रामक है।
गेहूँ

7

पर्यावरण चर

अपने Wxs दस्तावेज़ों को wixobj कोड पर संकलित करते समय, आप विभिन्न जानकारी निर्धारित करने के लिए पर्यावरण चर का उपयोग कर सकते हैं। उदाहरण के लिए, आप कहते हैं कि आप बदलना चाहते हैं कि कौन सी फाइलें परियोजना में शामिल हैं। कहते हैं कि आपके पास RELEASE_MODE नामक एक पर्यावरणीय चर है, जिसे आपने अपना MSI बनाने से ठीक पहले सेट किया है (या तो स्क्रिप्ट या मैन्युअल रूप से, इससे कोई फर्क नहीं पड़ता) आपके wix स्रोत में, आप कुछ ऐसा कर सकते हैं:

<define FILESOURCE = c:\source\output\bin\$(env.RELEASE_MODE) >

और फिर बाद में आपके कोड में, इसका उपयोग मक्खी पर अपने wxs दस्तावेज़ को बदलने के लिए करें, जैसे:

<Icon Id="myicon.ico" SourceFile="$(var.FILESOURCE)" />

1
इसके अलावा संकलन चर जैसे $ (कॉन्फ़िगरेशन) और $ (प्लेटफ़ॉर्म) उपलब्ध हैं। इसके अलावा msdn.microsoft.com/en-us/library/aa302186.aspx
si618

1
@ एसआईआई - आज से कुछ समय पहले, यह लिंक अब सक्रिय नहीं है। मुझे नवीनतम नहीं मिला।
पीटर एम।



7

संवाद का संपादन

संवादों को संपादित करने की एक अच्छी क्षमता एक संस्करण 4.0.1.7090 (या उच्चतर) में SharpDevelop का उपयोग कर रही है। इस टूल की मदद से एक स्टैंडअलोन डायलॉग (वाईएक्स स्रोतों से फाइलें जैसे कि इंस्टाडीडीआरएलजी.डब्ल्यूएक्सएस) को डिज़ाइन दृश्य में खोला, पूर्वावलोकन और संपादित किया जा सकता है।


बहुत बढ़िया, शार्पडेवलप ने इसका समर्थन नहीं किया।
anton.burger 13

6

IIS enable32BitAppOnWin64 फ्लैग सेट करना http://trycatchfail.com/blog/post/WiX-Snippet-change-enable32BitAppOnWin64.aspx

<InstallExecuteSequence>
   <RemoveExistingProducts After="InstallFinalize" />
   <Custom Action="ConfigureAppPool" After="InstallFinalize" >
     <![CDATA[NOT Installed AND VersionNT64 >= 600]]>         
   </Custom>
</InstallExecuteSequence>

<CustomAction Id="ConfigureAppPool" Return="check" Directory="TARGETDIR" ExeCommand="[SystemFolder]inetsrv\appcmd set apppool /apppool.name:[APPPOOLNAME] /enable32BitAppOnWin64:false" />

5

"स्थापित करने के लिए तैयार?" संशोधित करें संवाद (aka VerifyReadyDlg) दिए गए विकल्पों का सारांश प्रदान करने के लिए।

यह इस तरह दिख रहा है:
alt text http://i46.tinypic.com/s4th7t.jpg

जावास्क्रिप्ट कस्टमएक्शन के साथ ऐसा करें:


जावास्क्रिप्ट कोड:

// http://msdn.microsoft.com/en-us/library/aa372516(VS.85).aspx
var MsiViewModify = 
    {
        Refresh          : 0,
        Insert           : 1,
        Update           : 2,
        Assign           : 3,
        Replace          : 4,
        Merge            : 5,
        Delete           : 6,
        InsertTemporary  : 7,   // cannot permanently modify the MSI during install
        Validate         : 8,
        ValidateNew      : 9,
        ValidateField    : 10,
        ValidateDelete   : 11
    };


// http://msdn.microsoft.com/en-us/library/sfw6660x(VS.85).aspx
var Buttons = 
    {
        OkOnly           : 0,
        OkCancel         : 1,
        AbortRetryIgnore : 2,
        YesNoCancel      : 3
    };

var Icons= 
    {
        Critical         : 16,
        Question         : 32,
        Exclamation      : 48,
        Information      : 64
    }

var MsgKind =
    {
        Error            : 0x01000000,
        Warning          : 0x02000000,
        User             : 0x03000000,
        Log              : 0x04000000
    };

// http://msdn.microsoft.com/en-us/library/aa371254(VS.85).aspx
var MsiActionStatus = 
    {
        None             : 0,
        Ok               : 1, // success
        Cancel           : 2,
        Abort            : 3,
        Retry            : 4, // aka suspend?
        Ignore           : 5  // skip remaining actions; this is not an error.
    };

function UpdateReadyDialog_CA(sitename)
{
    try 
    {
        // can retrieve properties from the install session like this:
        var selectedWebSiteId = Session.Property("MSI_PROPERTY_HERE");

        // can retrieve requested feature install state like this:
        var fInstallRequested   = Session.FeatureRequestState("F.FeatureName");

        var text1 = "This is line 1 of text in the VerifyReadyDlg";

        var text2 = "This is the second line of custom text";

        var controlView     = Session.Database.OpenView("SELECT * FROM Control");
        controlView.Execute();

        var rec             = Session.Installer.CreateRecord(12);
        rec.StringData(1)   = "VerifyReadyDlg";    // Dialog_
        rec.StringData(2)   = "CustomVerifyText1"; // Control - can be any name
        rec.StringData(3)   = "Text";              // Type
        rec.IntegerData(4)  = 25;                  // X
        rec.IntegerData(5)  = 60;                  // Y
        rec.IntegerData(6)  = 320;                 // Width
        rec.IntegerData(7)  = 85;                  // Height
        rec.IntegerData(8)  = 2;                   // Attributes
        rec.StringData(9)   = "";                  // Property
        rec.StringData(10)  = vText1;              // Text
        rec.StringData(11)  = "";                  // Control_Next
        rec.StringData(12)  = "";                  // Help
        controlView.Modify(MsiViewModify.InsertTemporary, rec);

        rec                 = Session.Installer.CreateRecord(12);
        rec.StringData(1)   = "VerifyReadyDlg";    // Dialog_
        rec.StringData(2)   = "CustomVerifyText2"; // Control - any unique name
        rec.StringData(3)   = "Text";              // Type
        rec.IntegerData(4)  = 25;                  // X
        rec.IntegerData(5)  = 160;                 // Y
        rec.IntegerData(6)  = 320;                 // Width
        rec.IntegerData(7)  = 65;                  // Height
        rec.IntegerData(8)  = 2;                   // Attributes
        rec.StringData(9)   = "";                  // Property
        rec.StringData(10)  = text2;               // Text
        rec.StringData(11)  = "";                  // Control_Next
        rec.StringData(12)  = "";                  // Help
        controlView.Modify(MsiViewModify.InsertTemporary, rec);

        controlView.Close();
    }
    catch (exc1)
    {
        Session.Property("CA_EXCEPTION") = exc1.message ;
        LogException("UpdatePropsWithSelectedWebSite", exc1);
        return MsiActionStatus.Abort;
    }
    return MsiActionStatus.Ok;
}


function LogException(loc, exc)
{
    var record = Session.Installer.CreateRecord(0);
    record.StringData(0) = "Exception {" + loc + "}: " + exc.number + " : " + exc.message;
    Session.Message(MsgKind.Error + Icons.Critical + Buttons.btnOkOnly, record);
}

जावास्क्रिप्ट CA की घोषणा करें:

<Fragment>
  <Binary Id="IisScript_CA" SourceFile="CustomActions.js" />

  <CustomAction Id="CA.UpdateReadyDialog"
              BinaryKey="IisScript_CA"
              JScriptCall="UpdateReadyDialog_CA"
              Execute="immediate"
              Return="check" />
</Fragment>

एक बटन के लिए CA संलग्न करें। इस उदाहरण में, CA को निकाल दिया जाता है जब CustomizeDlg से अगला क्लिक किया जाता है:

<UI ...>
  <Publish Dialog="CustomizeDlg" Control="Next" Event="DoAction" 
           Value="CA.UpdateReadyDialog" Order="1"/>
</UI>

संबंधित SO प्रश्न: मैं रनटाइम पर, VerifyReadyDlg में प्रदर्शित होने वाला पाठ कैसे सेट कर सकता हूं?


निश्चित रूप से यह JScript नहीं होना चाहिए विंडोज़ स्क्रिप्टिंग भाषा बल्कि जावास्क्रिप्ट कि DHTML स्क्रिप्टिंग भाषा। संभवतः थोड़ा पांडित्यपूर्ण, लेकिन कुछ लोगों के लिए थोड़ा भ्रामक हो सकता है।
caveman_dick

5

ऐसे पुर्ज़े लगाएं, जिन्हें अलग-अलग अपने फ्रैगमेंट के अंदर अलग-अलग पैच किया जा सकता है

यह उत्पाद इंस्टालर और पैच बनाने दोनों के लिए जाता है कि यदि आप किसी अंश में कोई घटक शामिल करते हैं, तो आपको उस टुकड़े में सभी घटकों को शामिल करना होगा । इंस्टॉलर के निर्माण के मामले में, यदि आप किसी भी घटक संदर्भ को याद करते हैं, तो आपको light.exe से लिंकिंग त्रुटि मिलेगी। हालाँकि, जब आप एक पैच बनाते हैं, अगर आप किसी खंड में एकल घटक संदर्भ शामिल करते हैं, तो उस टुकड़े से सभी परिवर्तित घटक आपके पैच में दिखाई देंगे।

इस तरह:

<Fragment>
    <DirectoryRef Id="SampleProductFolder">
        <Component Id="SampleComponent1" Guid="{C28843DA-EF08-41CC-BA75-D2B99D8A1983}" DiskId="1">
            <File Id="SampleFile1" Source=".\$(var.Version)f\Sample1.txt" />
        </Component>
    </DirectoryRef>
</Fragment>

<Fragment>
    <DirectoryRef Id="SampleProductFolder">
        <Component Id="SampleComponent2" Guid="{6CEA5599-E7B0-4D65-93AA-0F2F64402B22}" DiskId="1">
           <File Id="SampleFile2" Source=".\$(var.Version)f\Sample2.txt" />
        </Component>
    </DirectoryRef>
</Fragment>

<Fragment>
    <DirectoryRef Id="SampleProductFolder">
        <Component Id="SampleComponent3" Guid="{4030BAC9-FAB3-426B-8D1E-DC1E2F72C2FC}" DiskId="1">
           <File Id="SampleFile3" Source=".\$(var.Version)f\Sample3.txt" />
        </Component>
    </DirectoryRef>
</Fragment>

इसके अलावा:

<Fragment>
    <DirectoryRef Id="SampleProductFolder">
        <Component Id="SampleComponent1" Guid="{C28843DA-EF08-41CC-BA75-D2B99D8A1983}" DiskId="1">
            <File Id="SampleFile1" Source=".\$(var.Version)\Sample1.txt" />
        </Component>

        <Component Id="SampleComponent2" Guid="{6CEA5599-E7B0-4D65-93AA-0F2F64402B22}" DiskId="1">
           <File Id="SampleFile2" Source=".\$(var.Version)\Sample2.txt" />
        </Component>

        <Component Id="SampleComponent3" Guid="{4030BAC9-FAB3-426B-8D1E-DC1E2F72C2FC}" DiskId="1">
           <File Id="SampleFile3" Source=".\$(var.Version)\Sample3.txt" />
        </Component>
    </DirectoryRef>
</Fragment>

साथ ही, जब वाईएक्स.एचम हेल्प फाइल से "विशुद्ध वाईएक्स" विषय का उपयोग करते हुए पैचिंग की जाती है, तो पैच बनाने के लिए इस प्रक्रिया का उपयोग करें:

torch.exe -p -xi 1.0\product.wixpdb 1.1\product.wixpdb -out patch\diff.wixmst
candle.exe patch.wxs
light.exe patch.wixobj -out patch\patch.wixmsp
pyro.exe patch\patch.wixmsp -out patch\patch.msp -t RTM patch\diff.wixmst

यह केवल उत्पाद का 1.1 संस्करण के लिए पर्याप्त नहीं है। अलग टुकड़ों में घटकों का उपयोग करके बनाया गया ।wixpdb। इसलिए शिपिंग से पहले अपने उत्पाद को सही ढंग से टुकड़े करना सुनिश्चित करें।


5

EixA को Wix3.0 और बाद से प्रिंट करना

1) जब आप अपना wix स्रोत कोड संकलित करते हैं, तो light.exe को WixUIExtension.dll कमांड लाइन में संदर्भ देना चाहिए। इसके लिए कमांड लाइन स्विच -ext का उपयोग करें।

2) यदि आप WixUIExtension.dll का संदर्भ जोड़ते हैं, तो आपका प्रोजेक्ट संकलित करने में विफल रहता है, डायलॉग आईडी के टकराव के कारण यह सबसे अधिक संभावना है, अर्थात आपका प्रोजेक्ट WixUIExtension.dll में कुछ मानक संवादों के रूप में एक ही आईडी संवाद का उपयोग कर रहा था। अपने संवादों को अलग पहचान दें। यह काफी आम समस्या है।

3) आपके लाइसेंस डायलॉग में आईडी "लाइसेंसटेक्स्ट" के साथ स्क्रॉल करने योग्य नियंत्रण होना चाहिए। जब यह प्रिंट होता है तो Wix नियंत्रण के इस नाम की खोज करता है।

<Control Id="LicenseText" Type="ScrollableText" X="20" Y="60" Width="330" Height="160" Sunken="yes" TabSkip="no">
    <Text SourceFile="License.rtf" />
</Control>

और एक पुशबटन जो कस्टम कार्रवाई को संदर्भित करता है

<Control Type="PushButton" Id="PrintButton" Width="57" Height="17" X="19" Y="244" Text="Print">
    <Publish Event="DoAction" Value="PrintEula">1</Publish>
</Control>

4) इस तरह = "PrintEula" आईडी के साथ CustomAction परिभाषित करें:

<CustomAction Id="PrintEula" BinaryKey="WixUIWixca" DllEntry="PrintEula" Return="ignore" Execute="immediate" />

नोट: Wix3.0 की तुलना में Wix3.0 में बाइनरीके अलग है और बिल्कुल "WixUIWixca" (केस संवेदनशील) होना चाहिए।

जब उपयोगकर्ता बटन दबाता है तो उसे मानक चयन प्रिंटर डायलॉग के साथ प्रस्तुत किया जाएगा और वह वहां से प्रिंट कर सकेगा।


5
  • हम GUI की पहली स्क्रीन में कहीं (छोटे) उत्पाद संस्करण प्रदर्शित करते हैं। क्योंकि लोग हर बार सही वर्जन चुनने की गलती करते हैं। (और हमें उम्र भर खोजते रहे डेवलपर्स ..)

  • हमने अपने विभिन्न वातावरणों के लिए कॉन्फ़िगरेशन के साथ ट्रांसफ़ॉर्म (.mst फ़ाइलें) भी उत्पन्न करने के लिए TFSBuild की स्थापना की है। (हम उन सभी वातावरणों के बारे में जानते हैं जिनकी हमें आवश्यकता है)।

चूंकि ग्रांट हॉलिडे द्वारा मूल वेबलॉग पोस्ट नीचे है, मैं इसकी सामग्री को यहां कॉपी करता हूं:


MSBuild कार्य XMLMarch 11 2008 से MSI ट्रांसफ़ॉर्म फ़ाइलों को जनरेट करने के लिए

अपनी पिछली पोस्ट में मैंने बताया कि कैसे आप MSI ट्रांसफॉर्म (* .mst) फाइलों को जेनेरिक MSI पैकेज से पर्यावरण-विशिष्ट कॉन्फ़िगरेशन सेटिंग्स को अलग करने के लिए उपयोग कर सकते हैं।

यद्यपि यह आपके कॉन्फ़िगरेशन में लचीलापन का एक स्तर प्रदान करता है, ट्रांसफ़ॉर्म फ़ाइलों के दो डाउन-साइड हैं:

  1. वे एक द्विआधारी प्रारूप हैं
  2. आप एक फ़ाइल को "संपादित" या "दृश्य" नहीं कर सकते। आपको इसे लागू करना होगा या यह देखना होगा कि इसमें क्या बदलाव शामिल हैं।

सौभाग्य से हम MSI "डेटाबेस" को खोलने के लिए Microsoft Windows इंस्टालर ऑब्जेक्ट लाइब्रेरी (c: windowssystem32msi.dll) का उपयोग कर सकते हैं और ट्रांसफ़ॉर्म फाइल्स बना सकते हैं।

क्रेडिट्स फिर से एलेक्स शेवचुक से - एमएसआई से वाईएक्स - भाग 7 तक - हमें VbScript के साथ इसे प्राप्त करने के तरीके को दिखाने के लिए ट्रांसफ़ॉर्म का उपयोग करके इंस्टॉलेशन को कस्टमाइज़ करना। अनिवार्य रूप से मैंने जो कुछ किया है, वह एलेक्स का उदाहरण लिया गया है और Interop.WindowsInstaller.dll का उपयोग करके मैंने MSBuild कार्य को कार्यान्वित किया है। MSBuild टास्क

स्रोत कोड डाउनलोड करें और यहां ट्रांसफॉर्मेसएक्सएमएल (~ 7Kb Zipped VS2008 सॉल्यूशन) देखें



2
हम अपने स्थानीयकरण फ़ाइल में WelcomeDlgTitle को फिर से परिभाषित करते हैं - महान काम करता है! <String Id = "WelcomeDlgTitle"> {\ _ WixUI_Font_Bigger} [ProductName] [ProductVersion] सेटअप विज़ार्ड में आपका स्वागत है </ string>
saschabeaumont

5

एक स्थापित पैकेज को तैनात करने से पहले मैं हमेशा इसकी सामग्री को नियंत्रित करता हूं।

यह कमांड लाइन पर एक साधारण कॉल है (टेरेंस पोस्ट के अनुसार) कमांड लाइन खोलें और दर्ज करें

msiexec /a Package.msi /qb TARGETDIR="%CD%\Extract" /l*vx "%CD\install.log%"

यह पैकेज सामग्री को वर्तमान पथ के साथ एक उपखंड 'अर्क' में निकालेगा।


4

ORCA के बजाय InstEd का उपयोग करें जो MSI तालिकाओं को देखने के लिए एक अच्छा उपकरण है। इसके अलावा यह दो संकुल को बदलने की क्षमता रखता है -> तुलना करने के लिए ...

अतिरिक्त कार्यक्षमता के साथ प्लस प्लस संस्करण उपलब्ध है। लेकिन यह भी मुफ्त संस्करण ओर्का के लिए एक अच्छा विकल्प प्रदान करता है।


4

COM इंटरोप के लिए .NET असेंबलियों को x86 / x64 संगतता के साथ पंजीकृत करना

NB यह टुकड़ा अनिवार्य रूप से REGASM असेंबली .ll / codebase के समान है

इस नमूने में कुछ चीजें चल रही हैं, इसलिए यहां कोड है और मैं इसे बाद में समझाऊंगा ...

  <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <?include $(sys.CURRENTDIR)\Config.wxi?>
  <?if $(var.Win64) ?>
  <?define CLSIDRoots = "CLSID;Wow6432Node\CLSID"?>
  <?else ?>
  <?define CLSIDRoots = "CLSID"?>
  <?endif?>
  <!-- ASCOM Driver Assembly with related COM registrations -->
  <Fragment>
    <DirectoryRef Id="INSTALLLOCATION" />
  </Fragment>
  <Fragment>
    <ComponentGroup Id="cgAscomDriver">
      <Component Id="cmpAscomDriver" Directory="INSTALLLOCATION" Guid="{0267031F-991D-4D88-A748-00EC6604171E}">
        <File Id="filDriverAssembly" Source="$(var.TiGra.Astronomy.AWRDriveSystem.TargetPath)" KeyPath="yes" Vital="yes" Assembly=".net" AssemblyApplication="filDriverAssembly"  />
        <RegistryKey Root="HKCR" Key="$(var.DriverId)"  Action="createAndRemoveOnUninstall">
          <RegistryValue Type="string" Value="$(var.DriverTypeName)"/>
          <RegistryKey Key="CLSID">
            <RegistryValue Type="string" Value="$(var.DriverGuid)" />
          </RegistryKey>
        </RegistryKey>
        <?foreach CLSID in $(var.CLSIDRoots) ?>
        <RegistryKey Root="HKCR" Key="$(var.CLSID)" Action="none">
          <RegistryKey Key="$(var.DriverGuid)" Action="createAndRemoveOnUninstall">
            <RegistryValue Type="string" Value="$(var.DriverTypeName)"/>
            <RegistryKey Key="InprocServer32">
              <RegistryValue Type="string" Value="mscoree.dll" />
              <RegistryValue Type="string" Name="ThreadingModel" Value="Both"/>
              <RegistryValue Type="string" Name="Class" Value="$(var.DriverTypeName)"/>
              <RegistryValue Type="string" Name="Assembly" Value="!(bind.assemblyFullname.filDriverAssembly)" />
              <RegistryValue Type="string" Name="RuntimeVersion" Value="v2.0.50727"/>
              <RegistryValue Type="string" Name="CodeBase" Value="file:///[#filDriverAssembly]" />
              <RegistryKey Key="!(bind.fileVersion.filDriverAssembly)" >
                <RegistryValue Type="string" Name="Class" Value="$(var.DriverTypeName)"/>
                <RegistryValue Type="string" Name="Assembly" Value="!(bind.assemblyFullname.filDriverAssembly)" />
                <RegistryValue Type="string" Name="RuntimeVersion" Value="v2.0.50727"/>
                <RegistryValue Type="string" Name="CodeBase" Value="file:///[#filDriverAssembly]" />
              </RegistryKey>
            </RegistryKey>
            <RegistryKey Key="ProgId" Action="createAndRemoveOnUninstall">
              <RegistryValue Type="string" Value="$(var.DriverId)" />
            </RegistryKey>
            <RegistryKey Key="Implemented Categories" Action="createAndRemoveOnUninstall" >
              <RegistryKey Key="{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}" Action="createAndRemoveOnUninstall" />
            </RegistryKey>
          </RegistryKey>
        </RegistryKey>
        <?endforeach?>
      </Component>
    </ComponentGroup>
  </Fragment>
</Wix>

यदि आप सोच रहे थे, यह वास्तव में एक ASCOM टेलीस्कोप चालक के लिए है

पहले, मैंने ऊपर से सलाह ली और एक अलग फ़ाइल में कुछ प्लेटफ़ॉर्म चर बनाए, आप एक्सएमएल के माध्यम से बिखरे हुए देख सकते हैं।

X86 बनाम x64 संगतता वाले शीर्ष सौदों के पास if-then-अन्यथा भाग। मेरे असेंबली ने x64 सिस्टम पर 'किसी भी सीपीयू' को लक्षित किया है, मुझे इसे दो बार रजिस्टर करना होगा, एक बार 64-बिट रजिस्ट्री में और एक बार 32-बिट Wow6432Nodeक्षेत्रों में। यदि तत्कालीन-मुझे इसके लिए सेट किया जाता है, तो मूल्यों को foreachबाद में लूप में उपयोग किया जाता है । इस तरह, मुझे केवल एक बार रजिस्ट्री कुंजियों को लिखना होगा (DRY सिद्धांत)।

फ़ाइल तत्व वास्तविक असेंबली dll को स्थापित और पंजीकृत करता है:

<File Id="filDriverAssembly" Source="$(var.TiGra.Astronomy.AWRDriveSystem.TargetPath)" KeyPath="yes" Vital="yes" Assembly=".net" AssemblyApplication="filDriverAssembly"  />

क्रांतिकारी कुछ भी नहीं है, लेकिन ध्यान दें Assembly=".net"- यह विशेषता अकेले विधानसभा को जीएसी में डाल देगी, जो कि मैं नहीं चाहता था। AssemblyApplicationअपने आप को वापस इंगित करने के लिए विशेषता का उपयोग करना बस Wix को GAC में फ़ाइल को रोकने का एक तरीका है। अब जब Wix को पता है कि यह एक .net असेंबली है, तो यह मुझे अपने XML के भीतर कुछ बाइंडर चर का उपयोग करने देता है, जैसे !(bind.assemblyFullname.filDriverAssembly)कि असेंबली का पूरा नाम प्राप्त करना।


3

DISABLEADVTSHORTCUTSअपने इंस्टॉलर में सभी विज्ञापित शॉर्टकटों को नियमित शॉर्टकट बनने के लिए मजबूर करने के लिए संपत्ति सेट करें , और आपको कीपथ के रूप में उपयोग किए जाने के लिए डमी रेज कुंजी को शामिल करने की आवश्यकता नहीं है।

<Property Id="DISABLEADVTSHORTCUTS" Value="1"/>

मुझे लगता है कि विंडोज इंस्टालर 4.0 या उच्चतर एक आवश्यकता है


2

यह एक अच्छी संरचना है, लेकिन मेरे अनुभव के आधार पर मुझे आश्चर्य है कि आप इन स्थितियों को कैसे संबोधित करते हैं:

A. आपके इंस्टॉल सभी को एक ही गंतव्य में उतरने के लिए प्रकट होते हैं। यदि किसी उपयोगकर्ता को एक बार में सभी 3 संस्करणों को स्थापित करने की आवश्यकता होती है, तो क्या आपकी प्रक्रिया इसे अनुमति देगी। क्या वे स्पष्ट रूप से बता सकते हैं कि वे हर निष्पादन योग्य के कौन से संस्करण को ट्रिगर कर रहे हैं?

ख। आप TEST और / या प्रशिक्षण में मौजूद नई फ़ाइलों को कैसे संभालते हैं लेकिन अभी तक LIVE में नहीं?


हाय ब्लेन, ए। नहीं वे नहीं है। InstallName config.wxi में है जो svn: externals द्वारा संदर्भित एकमात्र फ़ाइल नहीं है। तो यह प्रत्येक उत्पाद, यानी प्रत्येक उत्पाद के लिए अद्वितीय है। यही कारण है कि हम प्रत्येक संस्करण के लिए गाइड को संशोधित करते हैं। बी। गोटो ए। :) वे अपने अपग्रेडकोड ​​के साथ अलग एमएसआई हैं।
si618

1
वैसे, मुझे समझ में आया कि आपने मेरे प्रश्न का उत्तर एक प्रश्न के साथ क्यों दिया, लेकिन एक बार जब आप पर्याप्त प्रतिनिधि अंक प्राप्त कर लेते हैं, तो कृपया अपने प्रश्न को उत्तर टिप्पणियों में स्थानांतरित करें, अन्यथा धागा का पालन करना मुश्किल होगा।
si618

2

यहां बताया गया है बड़ी वेब परियोजनाओं को यह सत्यापित करने में मदद करने एक तरीका है कि तैनात फ़ाइलों की संख्या एक MSI (या मर्ज मॉड्यूल) में निर्मित फ़ाइलों की संख्या से मेल खाती है। मैंने अभी-अभी अपने मुख्य एप्लिकेशन (अभी भी विकास में) के खिलाफ कस्टम MSBuild कार्य को चलाया है और इसने कुछ गुम फाइलों को, ज्यादातर छवियों को उठाया है, लेकिन कुछ जावास्क्रिप्ट फ़ाइलों के माध्यम से फिसल गया था!

यह दृष्टिकोण (वाईएक्स प्रोजेक्ट के आफ्टरबिल्ड टारगेट में हुक करके एमएसआई की फाइल टेबल में झांकना) अन्य एप्लिकेशन प्रकारों के लिए काम कर सकता है जहां आपके पास अपेक्षित फ़ाइलों की पूरी सूची तक पहुंच है।


2

जब कोई इंस्‍टॉल अनइंस्‍टॉल या रीइंस्‍क्रिप्‍शन की अनुमति नहीं देता है और वापस रोल नहीं करता है, तो जबरन रिइंस्‍टॉल करना।

VBscript स्क्रिप्ट जो किसी भी कारण से अनइंस्टॉल नहीं कर रहा है एक इंस्टॉल को ओवरराइड करने के लिए उपयोग किया जाता है ..

Dim objShell
set objShell = wscript.createObject("wscript.shell")

iReturn = objShell.Run("CMD /K MsiExec.exe /I ""C:\Users\TheUser\Documents\Visual Studio 2010\Projects\InstallationTarget\HelloInstaller\bin\Debug\HelloInstaller.msi"" REINSTALLMODE=vomus REINSTALL=ALL",,True)

2

एक यूआई बनाएं जिसमें एक कस्टम एक्शन हो जो एक वेरिएबल सेट करेगा और यूआई कस्टम एक्शन में सेट किए गए वैरिएबल के आधार पर अगले बटन (या समान) को अक्षम / सक्षम करेगा।

जितना आप आगे सोचेंगे, उतना मुश्किल नहीं है, न कि बहुत मुश्किल से कहीं भी प्रलेखित नहीं!

शर्तों, गुणों और कस्टम क्रियाओं के साथ Wix सहभागिता

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.