it-swarm-eu.dev

Jak přidružit příponu souboru aktuálnímu spustitelnému souboru v jazyce C #

Chtěl bych spojit příponu souboru s aktuálním spustitelným souborem v jazyce C #. Tímto způsobem, když uživatel klepne na soubor poté v Průzkumníku, spustí můj spustitelný soubor s daným souborem jako první argument. V ideálním případě by také nastavil ikonu pro dané přípony souboru na ikonu pro můj spustitelný soubor. Děkuji všem.

51
Chris

Nezdá se, že by existovalo rozhraní .Net API pro přímé řízení přidružení souborů, ale můžete použít třídy registru pro čtení a zápis klíčů, které potřebujete.

Budete muset vytvořit klíč pod HKEY_CLASSES_ROOT s názvem nastaveným na příponu vašeho souboru (např .: ".txt"). Nastavit výchozí hodnotu tohoto klíče na jedinečný název pro typ souboru, například "Acme.TextFile". Potom vytvořte další klíč pod HKEY_CLASSES_ROOT s názvem nastaveným na "Acme.TextFile". Přidejte podklíč nazvaný "DefaultIcon" a nastavte výchozí hodnotu klíče na soubor obsahující ikonu, kterou chcete použít pro tento typ souboru. Přidat další sourozence s názvem "Shell". Pod klíčem Shell přidejte klíč pro každou akci, kterou chcete mít k dispozici prostřednictvím kontextové nabídky Průzkumníka, a nastavte výchozí hodnotu pro každý klíč na cestu ke spustitelnému souboru následovanou mezerou a znakem "% 1", který bude reprezentovat cestu souboru.

Zde je například ukázkový soubor registru pro vytvoření přidružení mezi soubory .txt a EmEditor:

 Editor registru systému Windows verze 5.00 
 
 [HKEY_CLASSES_ROOT .txt] 
 @ = "Emeditor.txt" 
 
 [HKEY_CLASSES_ROOT emitoritor.txt] 
 @ = "Textový dokument" 
 
 [HKEY_CLASSES_ROOT emitoritor.txt DefaultIcon] 
 @ = "% SystemRoot% SysWow64 imageres.dll, -102 "
 
 [HKEY_CLASSES_ROOT emitoritor.txt Shell] 
 
 [HKEY_CLASSES_ROOT emitoritor.txt Shell open] 
 
 [HKEY_CLASSES_ROOT emitoritor.txt Shell otevřený příkaz] 
 @ = "C: Programové soubory EmEditor EMEDITOR.EXE" 1 "" 
 
 [HKEY_CLASSES_ROOT emitoritor.txt Shell print] 
 
 [HKEY_CLASSES_ROOT emitoritor.txt Shell print command] 
 @ = "C" Programové soubory EmEditor EMEDITOR.EXE "/ p"% 1 "" 
40
X-Cubed

Pokud se rozhodnete jít cestou registru, nezapomeňte, že aktuální asociace uživatelů jsou pod HKEY_CURRENT_USER Třídy softwaru . Může být lepší přidat vaši aplikaci namísto tříd lokálních počítačů.

Pokud váš program bude spouštět omezený počet uživatelů, nebudete moci změnit CLASSES_ROOT.

25
Ishmaeel

Pokud používáte nasazení ClickOnce, je to pro vás vše zpracováno (alespoň v SP1 VS2008); jednoduše:

  • Vlastnosti projektu
  • Publikovat
  • Možnosti
  • Sdružení souborů
  • (přidejte vše, co potřebujete)

(Všimněte si, že musí být úplné důvěryhodnosti, cíl .NET 3.5 a musí být nastaveno pro použití offline)

Viz také MSDN: Jak: Vytvoření přidružení souborů pro aplikaci ClickOnce

11
Marc Gravell

Zde je úplný příklad:

public class FileAssociation
{
    public string Extension { get; set; }
    public string ProgId { get; set; }
    public string FileTypeDescription { get; set; }
    public string ExecutableFilePath { get; set; }
}

public class FileAssociations
{
    // needed so that Explorer windows get refreshed after the registry is updated
    [System.Runtime.InteropServices.DllImport("Shell32.dll")]
    private static extern int SHChangeNotify(int eventId, int flags, IntPtr item1, IntPtr item2);

    private const int SHCNE_ASSOCCHANGED = 0x8000000;
    private const int SHCNF_FLUSH = 0x1000;

    public static void EnsureAssociationsSet()
    {
        var filePath = Process.GetCurrentProcess().MainModule.FileName;
        EnsureAssociationsSet(
            new FileAssociation
            {
                Extension = ".binlog",
                ProgId = "MSBuildBinaryLog",
                FileTypeDescription = "MSBuild Binary Log",
                ExecutableFilePath = filePath
            },
            new FileAssociation
            {
                Extension = ".buildlog",
                ProgId = "MSBuildStructuredLog",
                FileTypeDescription = "MSBuild Structured Log",
                ExecutableFilePath = filePath
            });
    }

    public static void EnsureAssociationsSet(params FileAssociation[] associations)
    {
        bool madeChanges = false;
        foreach (var association in associations)
        {
            madeChanges |= SetAssociation(
                association.Extension,
                association.ProgId,
                association.FileTypeDescription,
                association.ExecutableFilePath);
        }

        if (madeChanges)
        {
            SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_FLUSH, IntPtr.Zero, IntPtr.Zero);
        }
    }

    public static bool SetAssociation(string extension, string progId, string fileTypeDescription, string applicationFilePath)
    {
        bool madeChanges = false;
        madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + extension, progId);
        madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + progId, fileTypeDescription);
        madeChanges |= SetKeyDefaultValue([email protected]"Software\Classes\{progId}\Shell\open\command", "\"" + applicationFilePath + "\" \"%1\"");
        return madeChanges;
    }

    private static bool SetKeyDefaultValue(string keyPath, string value)
    {
        using (var key = Registry.CurrentUser.CreateSubKey(keyPath))
        {
            if (key.GetValue(null) as string != value)
            {
                key.SetValue(null, value);
                return true;
            }
        }

        return false;
    }
9
Kirill Osenkov

Mohou existovat specifické důvody, proč se rozhodnete nepoužívat instalační balíček pro svůj projekt, ale instalační balíček je skvělým místem pro snadné provádění konfiguračních úloh aplikací, jako je registrace přípon souborů, přidávání zástupců na ploše atd.

Postup vytvoření přidružení přidávání souborů pomocí vestavěných nástrojů pro instalaci Visual Studio:

  1. V rámci stávajícího řešení C # přidejte nový projekt a vyberte typ projektu jako Other Project Types -> Setup and Deployment -> Setup Project (nebo zkuste Průvodce instalací)

  2. Konfigurujte instalační program (pokud potřebujete pomoc, máte k dispozici dostatek existujících dokumentů)

  3. Klepněte pravým tlačítkem myši na projekt nastavení v aplikaci Solution Explorer, vyberte View -> File Types a pak přidejte rozšíření, které chcete zaregistrovat spolu s programem jej spustit.

Tato metoda má navíc výhodu čištění až poté, co uživatel spustí odinstalaci pro vaši aplikaci.

7
Paul J

Konkrétní informace o způsobu „registru systému Windows“:

Vytvářím klíče pod HKEY_CURRENT_USER Třídy softwaru (jako Ishmaeel)

a postupujte podle instrukcí, které odpověděl X-Cubed.

Ukázkový kód vypadá takto:

private void Create_abc_FileAssociation()
{
    /***********************************/
    /**** Key1: Create ".abc" entry ****/
    /***********************************/
    Microsoft.Win32.RegistryKey key1 = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software", true);

    key1.CreateSubKey("Classes");
    key1 = key1.OpenSubKey("Classes", true);

    key1.CreateSubKey(".abc");
    key1 = key1.OpenSubKey(".abc", true);
    key1.SetValue("", "DemoKeyValue"); // Set default key value

    key1.Close();

    /*******************************************************/
    /**** Key2: Create "DemoKeyValue\DefaultIcon" entry ****/
    /*******************************************************/
    Microsoft.Win32.RegistryKey key2 = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software", true);

    key2.CreateSubKey("Classes");
    key2 = key2.OpenSubKey("Classes", true);

    key2.CreateSubKey("DemoKeyValue");
    key2 = key2.OpenSubKey("DemoKeyValue", true);

    key2.CreateSubKey("DefaultIcon");
    key2 = key2.OpenSubKey("DefaultIcon", true);
    key2.SetValue("", "\"" + "(The icon path you desire)" + "\""); // Set default key value

    key2.Close();

    /**************************************************************/
    /**** Key3: Create "DemoKeyValue\Shell\open\command" entry ****/
    /**************************************************************/
    Microsoft.Win32.RegistryKey key3 = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software", true);

    key3.CreateSubKey("Classes");
    key3 = key3.OpenSubKey("Classes", true);

    key3.CreateSubKey("DemoKeyValue");
    key3 = key3.OpenSubKey("DemoKeyValue", true);

    key3.CreateSubKey("Shell");
    key3 = key3.OpenSubKey("Shell", true);

    key3.CreateSubKey("open");
    key3 = key3.OpenSubKey("open", true);

    key3.CreateSubKey("command");
    key3 = key3.OpenSubKey("command", true);
    key3.SetValue("", "\"" + "(The application path you desire)" + "\"" + " \"%1\""); // Set default key value

    key3.Close();
}

Stačí ukázat, že jste rychlá demo, velmi snadno pochopitelná. Můžete změnit tyto klíčové hodnoty a vše je dobré jít.

5
Strong

Přidružení souborů jsou definována v registru pod HKEY_CLASSES_ROOT.

Je zde příklad VB.NET zde že můžu snadno portovat na C #.

2
Steve Morgan

Níže uvedený kód je funkce, kterou by měl fungovat, přidává požadované hodnoty do registru systému Windows. Obvykle spouštím SelfCreateAssociation (". Abc") v mém spustitelném souboru. (konstruktor formulářů nebo onload nebo onshown) Aktualizuje záznam registru pro aktuálního uživatele, pokaždé, když je spustitelný spustitelný soubor. (dobré pro ladění, pokud máte nějaké změny). Pokud potřebujete podrobné informace o zahrnutých klíčích registru, podívejte se na tento odkaz MSDN.

https://msdn.Microsoft.com/en-us/library/windows/desktop/dd758090(v=vs.85).aspx

Chcete-li získat více informací o obecném klíči registru ClassesRoot. Viz tento článek MSDN.

https://msdn.Microsoft.com/en-us/library/windows/desktop/ms724475(v=vs.85).aspx

public enum KeyHiveSmall
{
    ClassesRoot,
    CurrentUser,
    LocalMachine,
}

/// <summary>
/// Create an associaten for a file extension in the windows registry
/// CreateAssociation(@"vendor.application",".tmf","Tool file",@"C:\Windows\SYSWOW64\notepad.exe",@"%SystemRoot%\SYSWOW64\notepad.exe,0");
/// </summary>
/// <param name="ProgID">e.g. vendor.application</param>
/// <param name="extension">e.g. .tmf</param>
/// <param name="description">e.g. Tool file</param>
/// <param name="application">e.g.  @"C:\Windows\SYSWOW64\notepad.exe"</param>
/// <param name="icon">@"%SystemRoot%\SYSWOW64\notepad.exe,0"</param>
/// <param name="Hive">e.g. The user-specific settings have priority over the computer settings. KeyHive.LocalMachine  need admin rights</param>
public static void CreateAssociation(string ProgID, string extension, string description, string application, string icon, KeyHiveSmall Hive = KeyHiveSmall.CurrentUser)
{
    RegistryKey selectedKey = null;

    switch (Hive)
    {
        case KeyHiveSmall.ClassesRoot:
            Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(extension).SetValue("", ProgID);
            selectedKey = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(ProgID);
            break;

        case KeyHiveSmall.CurrentUser:
            Microsoft.Win32.Registry.CurrentUser.CreateSubKey(@"Software\Classes\" + extension).SetValue("", ProgID);
            selectedKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(@"Software\Classes\" + ProgID);
            break;

        case KeyHiveSmall.LocalMachine:
            Microsoft.Win32.Registry.LocalMachine.CreateSubKey(@"Software\Classes\" + extension).SetValue("", ProgID);
            selectedKey = Microsoft.Win32.Registry.LocalMachine.CreateSubKey(@"Software\Classes\" + ProgID);
            break;
    }

    if (selectedKey != null)
    {
        if (description != null)
        {
            selectedKey.SetValue("", description);
        }
        if (icon != null)
        {
            selectedKey.CreateSubKey("DefaultIcon").SetValue("", icon, RegistryValueKind.ExpandString);
            selectedKey.CreateSubKey(@"Shell\Open").SetValue("icon", icon, RegistryValueKind.ExpandString);
        }
        if (application != null)
        {
            selectedKey.CreateSubKey(@"Shell\Open\command").SetValue("", "\"" + application + "\"" + " \"%1\"", RegistryValueKind.ExpandString);
        }
    }
    selectedKey.Flush();
    selectedKey.Close();
}

 /// <summary>
    /// Creates a association for current running executable
    /// </summary>
    /// <param name="extension">e.g. .tmf</param>
    /// <param name="Hive">e.g. KeyHive.LocalMachine need admin rights</param>
    /// <param name="description">e.g. Tool file. Displayed in Explorer</param>
    public static void SelfCreateAssociation(string extension, KeyHiveSmall Hive = KeyHiveSmall.CurrentUser, string description = "")
    {
        string ProgID = System.Reflection.Assembly.GetExecutingAssembly().EntryPoint.DeclaringType.FullName;
        string FileLocation = System.Reflection.Assembly.GetExecutingAssembly().Location;
        CreateAssociation(ProgID, extension, description, FileLocation, FileLocation + ",0", Hive);
    }
2
Carsten R.

Existují dva nástroje cmd, které jsou již od Windows 7, což usnadňuje vytváření jednoduchých asociací souborů. Jsou assoc a ftype . Zde je základní vysvětlení každého příkazu.

  • Assoc - sdružuje příponu souboru (jako '.txt') s „typem souboru".
  • FType - definuje spustitelný soubor, který se má spustit, když uživatel otevře daný typ souboru.

Všimněte si, že se jedná o nástroje cmd a ne spustitelné soubory (exe). To znamená, že mohou být spuštěny pouze v okně cmd nebo pomocí ShellExecute s "cmd/c assoc." Více se o nich dozvíte na odkazech nebo zadáním "assoc /?" a "ftype /?" na cmd Prompt. 

Chcete-li tedy přiřadit aplikaci k rozšíření .bob, můžete otevřít okno cmd (WindowKey + R, zadejte příkaz cmd, stiskněte klávesu enter) a spusťte následující postup:

assoc .bob=BobFile
ftype BobFile=c:\temp\BobView.exe "%1"

To je mnohem jednodušší, než pokazit s registrem, a to je více pravděpodobné, že práce v budoucích Windows verze. 

Zalomování je zde funkce C # pro vytvoření přidružení souborů:

public static int setFileAssociation(string[] extensions, string fileType, string openCommandString) {
    int v = execute("cmd", "/c ftype " + fileType + "=" + openCommandString);
    foreach (string ext in extensions) {
        v = execute("cmd", "/c assoc " + ext + "=" + fileType);
        if (v != 0) return v;
    }
    return v;
}
public static int execute(string exeFilename, string arguments) {
    ProcessStartInfo startInfo = new ProcessStartInfo();
    startInfo.CreateNoWindow = false;
    startInfo.UseShellExecute = true;
    startInfo.FileName = exeFilename;
    startInfo.WindowStyle = ProcessWindowStyle.Hidden;
    startInfo.Arguments = arguments;
    try {
        using (Process exeProcess = Process.Start(startInfo)) {
            exeProcess.WaitForExit();
            return exeProcess.ExitCode;
        }
    } catch {
        return 1;
    }
}
0
Mike