Sto cercando di scoprire come leggere / scrivere nelle proprietà del file estese in C #, ad esempio Commento, Bit Rate, Data di accesso, Categoria ecc. Che puoi vedere in Windows Explorer. Qualche idea su come fare questo? EDIT: leggerò / scriverò principalmente su file video (AVI / DIVX / ...)

Per quelli che non vanno matti per VB, eccolo in c #:

Nota, devi aggiungere un riferimento a Microsoft Shell Controls and Automation dalla scheda COM della finestra di dialogo Riferimenti.

public static void Main(string[] args)
{
    List<string> arrHeaders = new List<string>();

    Shell32.Shell shell = new Shell32.Shell();
    Shell32.Folder objFolder;

    objFolder = shell.NameSpace(@"C:\temp\testprop");

    for( int i = 0; i < short.MaxValue; i++ )
    {
        string header = objFolder.GetDetailsOf(null, i);
        if (String.IsNullOrEmpty(header))
            break;
        arrHeaders.Add(header);
    }

    foreach(Shell32.FolderItem2 item in objFolder.Items())
    {
        for (int i = 0; i < arrHeaders.Count; i++)
        {
            Console.WriteLine(
              $"{i}\t{arrHeaders[i]}: {objFolder.GetDetailsOf(item, i)}");
        }
    }
}

C'è un articolo CodeProject per un lettore ID3. E un thread su kixtart.org che contiene ulteriori informazioni per altre proprietà. Fondamentalmente, è necessario chiamare il GetDetailsOf()metodo sull'oggetto shell della cartella per shell32.dll.

Soluzione 2016

Aggiungi i seguenti pacchetti NuGet al tuo progetto:

• Microsoft.WindowsAPICodePack-Shell di Microsoft
• Microsoft.WindowsAPICodePack-Core di Microsoft

Proprietà di lettura e scrittura

using Microsoft.WindowsAPICodePack.Shell;
using Microsoft.WindowsAPICodePack.Shell.PropertySystem;

string filePath = @"C:\temp\example.docx";
var file = ShellFile.FromFilePath(filePath);

// Read and Write:

string[] oldAuthors = file.Properties.System.Author.Value;
string oldTitle = file.Properties.System.Title.Value;

file.Properties.System.Author.Value = new string[] { "Author #1", "Author #2" };
file.Properties.System.Title.Value = "Example Title";

// Alternate way to Write:

ShellPropertyWriter propertyWriter =  file.Properties.GetPropertyWriter();
propertyWriter.WriteProperty(SystemProperties.System.Author, new string[] { "Author" });
propertyWriter.Close();

Importante:

Il file deve essere valido, creato dallo specifico software assegnato. Ogni tipo di file ha proprietà di file estese specifiche e non tutti sono scrivibili.

Se fai clic con il pulsante destro del mouse su un file sul desktop e non puoi modificare una proprietà, non sarai in grado di modificarlo anche nel codice.

Esempio:

• Crea file txt sul desktop, rinomina la sua estensione in docx. Non puoi modificarne la proprietà Authoro Title.
• Aprilo con Word, modificalo e salvalo. Ora puoi.

Quindi assicurati di usarne alcuni try catch

Ulteriore argomento: MSDN: implementazione di gestori di proprietà

Questo esempio in VB.NET legge tutte le proprietà estese:

Sub Main()
        Dim arrHeaders(35)

        Dim shell As New Shell32.Shell
        Dim objFolder As Shell32.Folder

        objFolder = shell.NameSpace("C:\tmp")

        For i = 0 To 34
            arrHeaders(i) = objFolder.GetDetailsOf(objFolder.Items, i)
        Next
        For Each strFileName In objfolder.Items
            For i = 0 To 34
                Console.WriteLine(i & vbTab & arrHeaders(i) & ": " & objfolder.GetDetailsOf(strFileName, i))
            Next
        Next

    End Sub

È necessario aggiungere un riferimento a Microsoft Shell Controls and Automation dalla scheda COM della finestra di dialogo Riferimenti .

Grazie ragazzi per questo thread! Mi ha aiutato quando volevo capire la versione del file di un exe. Tuttavia, avevo bisogno di capire da solo l'ultima parte di ciò che viene chiamato Proprietà estese.

Se apri le proprietà di un file exe (o dll) in Esplora risorse, ottieni una scheda Versione e una visualizzazione delle proprietà estese di quel file. Volevo accedere a uno di quei valori.

La soluzione a questo è l'indicizzatore della proprietà FolderItem.ExtendedProperty e se si rilasciano tutti gli spazi nel nome della proprietà, si otterrà il valore. Ad esempio, File Version diventa FileVersion, e il gioco è fatto.

Spero che questo aiuti chiunque altro, ho solo pensato di aggiungere queste informazioni a questo thread. Saluti!

GetDetailsOf()Metodo: recupera i dettagli su un elemento in una cartella. Ad esempio, le sue dimensioni, il tipo o l'ora dell'ultima modifica. Le proprietà del file possono variare in base alla Windows-OSversione.

List<string> arrHeaders = new List<string>();

 Shell shell = new ShellClass();
 Folder rFolder = shell.NameSpace(_rootPath);
 FolderItem rFiles = rFolder.ParseName(filename);

 for (int i = 0; i < short.MaxValue; i++)
 {
      string value = rFolder.GetDetailsOf(rFiles, i).Trim();
      arrHeaders.Add(value);
 }

• Dopo aver esaminato una serie di soluzioni su questo thread e altrove, è stato messo insieme il codice seguente. Questo è solo per leggere una proprietà.
• Non sono riuscito a far funzionare la funzione Shell32.FolderItem2.ExtendedProperty, si suppone che prenda un valore stringa e restituisca il valore e il tipo corretti per quella proprietà ... questo era sempre nullo per me e le risorse di riferimento per gli sviluppatori erano molto scarse.
• Il WindowsApiCodePack sembra essere stato abbandonato da Microsoft che ci porta il codice qui sotto.

Uso:

string propertyValue = GetExtendedFileProperty("c:\\temp\\FileNameYouWant.ext","PropertyYouWant");

1. Ti restituirà il valore della proprietà estesa che desideri come stringa per il file e il nome della proprietà specificati.
2. Esegue il ciclo solo finché non trova la proprietà specificata, non finché tutte le proprietà non vengono scoperte come un codice di esempio

3. Funzionerà su versioni di Windows come Windows Server 2008, dove riceverai l'errore "Impossibile eseguire il cast di un oggetto COM di tipo" System .__ ComObject "nel tipo di interfaccia" Shell32.Shell "" se si tenta di creare normalmente l'oggetto Shell32.

   public static string GetExtendedFileProperty(string filePath, string propertyName)
   {
       string value = string.Empty;
       string baseFolder = Path.GetDirectoryName(filePath);
       string fileName = Path.GetFileName(filePath);
   
       //Method to load and execute the Shell object for Windows server 8 environment otherwise you get "Unable to cast COM object of type 'System.__ComObject' to interface type 'Shell32.Shell'"
       Type shellAppType = Type.GetTypeFromProgID("Shell.Application");
       Object shell = Activator.CreateInstance(shellAppType);
       Shell32.Folder shellFolder = (Shell32.Folder)shellAppType.InvokeMember("NameSpace", System.Reflection.BindingFlags.InvokeMethod, null, shell, new object[] { baseFolder });
   
       //Parsename will find the specific file I'm looking for in the Shell32.Folder object
       Shell32.FolderItem folderitem = shellFolder.ParseName(fileName);
       if (folderitem != null)
       {
           for (int i = 0; i < short.MaxValue; i++)
           {
               //Get the property name for property index i
               string property = shellFolder.GetDetailsOf(null, i);
   
               //Will be empty when all possible properties has been looped through, break out of loop
               if (String.IsNullOrEmpty(property)) break;
   
               //Skip to next property if this is not the specified property
               if (property != propertyName) continue;    
   
               //Read value of property
               value = shellFolder.GetDetailsOf(folderitem, i);
           }
       }
       //returns string.Empty if no value was found for the specified property
       return value;
   }

La risposta di Jerker è un po 'più semplice. Ecco un esempio di codice che funziona da MS :

var folder = new Shell().NameSpace(folderPath);
foreach (FolderItem2 item in folder.Items())
{
    var company = item.ExtendedProperty("Company");
    var author = item.ExtendedProperty("Author");
    // Etc.
}

Per coloro che non possono fare riferimento staticamente a shell32, puoi invocarlo dinamicamente in questo modo:

var shellAppType = Type.GetTypeFromProgID("Shell.Application");
dynamic shellApp = Activator.CreateInstance(shellAppType);
var folder = shellApp.NameSpace(folderPath);
foreach (var item in folder.Items())
{
    var company = item.ExtendedProperty("Company");
    var author = item.ExtendedProperty("Author");
    // Etc.
}

Non sono sicuro di quali tipi di file stai cercando di scrivere le proprietà, ma taglib-sharp è un'eccellente libreria di tag open source che racchiude bene tutte queste funzionalità. Ha un sacco di supporto integrato per la maggior parte dei tipi di file multimediali più diffusi, ma ti consente anche di eseguire tag più avanzati praticamente con qualsiasi file.

EDIT: ho aggiornato il collegamento a taglib sharp. Il vecchio collegamento non funzionava più.

EDIT: aggiornato ancora una volta il collegamento per il commento di kzu.

Ecco una soluzione per leggere - non scrivere - le proprietà estese in base a ciò che ho trovato in questa pagina e in aiuto con gli oggetti shell32 .

Per essere chiari questo è un trucco. Sembra che questo codice funzionerà ancora su Windows 10 ma colpirà alcune proprietà vuote. La versione precedente di Windows dovrebbe utilizzare:

        var i = 0;
        while (true)
        {
            ...
            if (String.IsNullOrEmpty(header)) break;
            ...
            i++;

Su Windows 10 presumiamo che ci siano circa 320 proprietà da leggere e saltiamo semplicemente le voci vuote:

    private Dictionary<string, string> GetExtendedProperties(string filePath)
    {
        var directory = Path.GetDirectoryName(filePath);
        var shell = new Shell32.Shell();
        var shellFolder = shell.NameSpace(directory);
        var fileName = Path.GetFileName(filePath);
        var folderitem = shellFolder.ParseName(fileName);
        var dictionary = new Dictionary<string, string>();
        var i = -1;
        while (++i < 320)
        {
            var header = shellFolder.GetDetailsOf(null, i);
            if (String.IsNullOrEmpty(header)) continue;
            var value = shellFolder.GetDetailsOf(folderitem, i);
            if (!dictionary.ContainsKey(header)) dictionary.Add(header, value);
            Console.WriteLine(header +": " + value);
        }
        Marshal.ReleaseComObject(shell);
        Marshal.ReleaseComObject(shellFolder);
        return dictionary;
    }

Come accennato, è necessario fare riferimento all'assembly Com Interop.Shell32.

Se ricevi un'eccezione relativa a STA, troverai la soluzione qui:

Eccezione quando si utilizza Shell32 per ottenere le proprietà estese del file

Non ho idea di come sarebbero i nomi di queste proprietà su un sistema esterno e non sono riuscito a trovare informazioni su quali costanti localizzabili utilizzare per accedere al dizionario. Ho anche scoperto che non tutte le proprietà della finestra di dialogo Proprietà erano presenti nel dizionario restituito.

A proposito, questo è terribilmente lento e, almeno su Windows 10, l'analisi delle date nella stringa recuperata sarebbe una sfida, quindi l'utilizzo di questo sembra essere una cattiva idea con cui iniziare.

Su Windows 10 dovresti assolutamente usare la libreria Windows.Storage che contiene SystemPhotoProperties, SystemMusicProperties ecc. Https://docs.microsoft.com/en-us/windows/uwp/files/quickstart-getting-file-properties

E infine, ho pubblicato una soluzione molto migliore che utilizza WindowsAPICodePack lì