usar una propiedades propiedad informatica descriptores definir declarar cuando como clase atributos acceso c# windows file properties visual-studio-2015

c# - una - propiedades informatica



Extracción de propiedades de archivos de Windows(propiedades personalizadas) C# (5)

Hay un conjunto de paquetes de NuGet llamados NetOffice que puedes usar. Hay paquetes para cada una de las aplicaciones de Office, más algunos ensamblajes principales. Obtenga NetOffice.Word y NetOffice.Excel e instálelos en su solución. Hay un poco de documentación en el sitio de Codeplex , pero tuve que buscar en la fuente para entender realmente lo que estaba pasando. Aquí hay un programa de muestra:

using NetOffice.OfficeApi; using System; namespace Office_Doc_Reader { class Program { static void Main(string[] args) { using (var wordApp = new NetOffice.WordApi.Application()) using (var excelApp = new NetOffice.ExcelApi.Application()) { var doc = wordApp.Documents.Open("C://Users//John//Desktop//test.docx"); var xls = excelApp.Workbooks.Open("C://Users//John//Desktop//test.xlsx"); var customProperties = (DocumentProperties)doc.CustomDocumentProperties; foreach (var property in customProperties) { Console.WriteLine(String.Format("Name: {0}, Value: {1}, Type: {2}", property.Name, property.Value, property.Type)); } customProperties = (DocumentProperties)xls.CustomDocumentProperties; foreach (var property in customProperties) { Console.WriteLine(String.Format("Name: {0}, Value: {1}, Type: {2}", property.Name, property.Value, property.Type)); } } Console.ReadKey(); } } }

Eso muestra los siguientes resultados:

Name: Custom prop 1, Value: Text Value, Type: msoPropertyTypeString Name: Custom prop 2, Value: 2/21/2016 12:00:00 AM, Type: msoPropertyTypeDate Name: Custom prop 3, Value: 42, Type: msoPropertyTypeNumber Name: Custom prop 4, Value: True, Type: msoPropertyTypeBoolean Name: Foo, Value: abc, Type: msoPropertyTypeString Name: Bar, Value: 1/1/1970 12:00:00 AM, Type: msoPropertyTypeDate Name: Baz, Value: 3.14159, Type: msoPropertyTypeFloat Name: Qux, Value: False, Type: msoPropertyTypeBoolean

Para un archivo de Word y Excel con estas propiedades:

No he trabajado con esto en absoluto, por lo que no podré ir mucho más allá de esto. Espero eso ayude.

En Word / Excel tienes la posibilidad de agregar propiedades personalizadas. (Ver imagen) Propiedades personalizadas . Como ustedes pueden ver, hay un campo: "Propiedades:", puede agregar cualquier información que desee allí. Cuando guarde el archivo y vaya a la ubicación del archivo en la carpeta, puede hacer clic derecho -> Propiedades y tiene todas las pestañas: General / Seguridad / Detalles / Versiones anteriores. Con la característica agregas la pestaña Personalizar.

Ahora quiero obtener esta información a través de la codificación: información de propiedades personalizadas . Y luego extraerlo al bloc de notas. Hasta ahora Shell32 usado Shell32 pero solo obtengo la información que se encuentra en la pestaña Detalles. Hice una investigación y vi algunas posibilidades con DSOfile.dll . ¿Pero quiero saber si existe la posibilidad de hacer esto sin instalar otra DLL? Este es mi código hasta ahora con el Shell32 .

static void Main(string[] args) { //using (StreamWriter writer = new StreamWriter(@"filepathhere")) //{ //Console.SetOut(writer); ReadProperties(); //} } static void ReadProperties() { List<string> arrHeaders = new List<string>(); Shell shell = new Shell(); Folder objFolder = shell.NameSpace(@"filepathhere"); FolderItem objFolderItem = objFolder.ParseName("filehere.doc"); for (int i = 0; i < short.MaxValue; i++) { string header = objFolder.GetDetailsOf(objFolder, i); if (String.IsNullOrEmpty(header)) break; arrHeaders.Add(header); } for ( int i = 0; i < arrHeaders.Count; i++) { Console.WriteLine("{0}/t{1}: {2}", i, arrHeaders[i], objFolder.GetDetailsOf(objFolderItem, i)); } Console.ReadKey(); }

¡Gracias por adelantado!

Desu

Históricamente, estas propiedades fueron definidas por la tecnología llamada "Almacenamiento estructurado". La primera implementación de almacenamiento estructurado es el formato de archivo compuesto antiguo (pero todavía muy vivo)

Después de eso, Microsoft agregó capacidades de almacenamiento estructurado directamente a NTFS . Esto le permite definir propiedades como autor o título en cualquier archivo (incluso .txt). Aunque la interfaz de usuario de Explorer no te deja hacer esto por alguna razón, creo que todavía funciona mediante programación.

Y luego, con Vista, Microsoft reinició todo eso e introdujo un superconjunto de todo esto: el sistema de propiedades de Windows .

Desafortunadamente, no hay una API .NET en el marco para todo esto. Pero Microsoft creó una biblioteca de código abierto .NET llamada Windows API CodePack. Por lo tanto, la forma más fácil de extraer propiedades es agregar una referencia al NugetPackage de WindowsAPICodePack Core y puede usarlo así:

static void Main(string[] args) { foreach (var prop in new ShellPropertyCollection(@"mypath/myfile")) { Console.WriteLine(prop.CanonicalName + "=" + prop.ValueAsObject); } }

Si no desea agregar DLL adicionales, puede extraer el código ShellPropertyCollection de la fuente de WindowsAPICodePack ( paquete de códigos de API de Windows: ¿Dónde está? ). Es todo un trabajo pero factible.

Otra solución en su caso, es utilizar la antigua API nativa de Structure Storage. He proporcionado una muestra que hace esto. Aquí es cómo puedes usarlo:

static void Main(string[] args) { foreach (var prop in new StructuredStorage(@"mypath/myfile").Properties) { Console.WriteLine(prop.Name + "=" + prop.Value); } } public sealed class StructuredStorage { public static readonly Guid SummaryInformationFormatId = new Guid("{F29F85E0-4FF9-1068-AB91-08002B27B3D9}"); public static readonly Guid DocSummaryInformationFormatId = new Guid("{D5CDD502-2E9C-101B-9397-08002B2CF9AE}"); public static readonly Guid UserDefinedPropertiesId = new Guid("{D5CDD505-2E9C-101B-9397-08002B2CF9AE}"); private List<StructuredProperty> _properties = new List<StructuredProperty>(); public StructuredStorage(string filePath) { if (filePath == null) throw new ArgumentNullException("filePath"); FilePath = filePath; IPropertySetStorage propertySetStorage; int hr = StgOpenStorageEx(FilePath, STGM.STGM_READ | STGM.STGM_SHARE_DENY_NONE | STGM.STGM_DIRECT_SWMR, STGFMT.STGFMT_ANY, 0, IntPtr.Zero, IntPtr.Zero, typeof(IPropertySetStorage).GUID, out propertySetStorage); if (hr == STG_E_FILENOTFOUND || hr == STG_E_PATHNOTFOUND) throw new FileNotFoundException(null, FilePath); if (hr != 0) throw new Win32Exception(hr); try { LoadPropertySet(propertySetStorage, SummaryInformationFormatId); LoadPropertySet(propertySetStorage, DocSummaryInformationFormatId); } finally { Marshal.ReleaseComObject(propertySetStorage); } // for some reason we can''t read this one on the same COM ref? LoadProperties(UserDefinedPropertiesId); } public string FilePath { get; private set; } public IReadOnlyList<StructuredProperty> Properties { get { return _properties; } } private void LoadPropertySet(IPropertySetStorage propertySetStorage, Guid fmtid) { IPropertyStorage propertyStorage; int hr = propertySetStorage.Open(fmtid, STGM.STGM_READ | STGM.STGM_SHARE_EXCLUSIVE, out propertyStorage); if (hr == STG_E_FILENOTFOUND || hr == STG_E_ACCESSDENIED) return; if (hr != 0) throw new Win32Exception(hr); IEnumSTATPROPSTG es; propertyStorage.Enum(out es); if (es == null) return; try { var stg = new STATPROPSTG(); int fetched; do { hr = es.Next(1, ref stg, out fetched); if (hr != 0 && hr != 1) throw new Win32Exception(hr); if (fetched == 1) { string name = GetPropertyName(fmtid, propertyStorage, stg); var propsec = new PROPSPEC[1]; propsec[0] = new PROPSPEC(); propsec[0].ulKind = stg.lpwstrName != null ? PRSPEC.PRSPEC_LPWSTR : PRSPEC.PRSPEC_PROPID; IntPtr lpwstr = IntPtr.Zero; if (stg.lpwstrName != null) { lpwstr = Marshal.StringToCoTaskMemUni(stg.lpwstrName); propsec[0].union.lpwstr = lpwstr; } else { propsec[0].union.propid = stg.propid; } var vars = new PROPVARIANT[1]; vars[0] = new PROPVARIANT(); try { hr = propertyStorage.ReadMultiple(1, propsec, vars); if (hr != 0) throw new Win32Exception(hr); } finally { if (lpwstr != IntPtr.Zero) { Marshal.FreeCoTaskMem(lpwstr); } } object value; try { switch (vars[0].vt) { case VARTYPE.VT_BOOL: value = vars[0].union.boolVal != 0 ? true : false; break; case VARTYPE.VT_BSTR: value = Marshal.PtrToStringUni(vars[0].union.bstrVal); break; case VARTYPE.VT_CY: value = decimal.FromOACurrency(vars[0].union.cyVal); break; case VARTYPE.VT_DATE: value = DateTime.FromOADate(vars[0].union.date); break; case VARTYPE.VT_DECIMAL: IntPtr dec = IntPtr.Zero; Marshal.StructureToPtr(vars[0], dec, false); value = Marshal.PtrToStructure(dec, typeof(decimal)); break; case VARTYPE.VT_DISPATCH: value = Marshal.GetObjectForIUnknown(vars[0].union.pdispVal); break; case VARTYPE.VT_ERROR: case VARTYPE.VT_HRESULT: value = vars[0].union.scode; break; case VARTYPE.VT_FILETIME: value = DateTime.FromFileTime(vars[0].union.filetime); break; case VARTYPE.VT_I1: value = vars[0].union.cVal; break; case VARTYPE.VT_I2: value = vars[0].union.iVal; break; case VARTYPE.VT_I4: value = vars[0].union.lVal; break; case VARTYPE.VT_I8: value = vars[0].union.hVal; break; case VARTYPE.VT_INT: value = vars[0].union.intVal; break; case VARTYPE.VT_LPSTR: value = Marshal.PtrToStringAnsi(vars[0].union.pszVal); break; case VARTYPE.VT_LPWSTR: value = Marshal.PtrToStringUni(vars[0].union.pwszVal); break; case VARTYPE.VT_R4: value = vars[0].union.fltVal; break; case VARTYPE.VT_R8: value = vars[0].union.dblVal; break; case VARTYPE.VT_UI1: value = vars[0].union.bVal; break; case VARTYPE.VT_UI2: value = vars[0].union.uiVal; break; case VARTYPE.VT_UI4: value = vars[0].union.ulVal; break; case VARTYPE.VT_UI8: value = vars[0].union.uhVal; break; case VARTYPE.VT_UINT: value = vars[0].union.uintVal; break; case VARTYPE.VT_UNKNOWN: value = Marshal.GetObjectForIUnknown(vars[0].union.punkVal); break; default: value = null; break; } } finally { PropVariantClear(ref vars[0]); } var property = new StructuredProperty(fmtid, name, stg.propid); property.Value = value; _properties.Add(property); } } while (fetched == 1); } finally { Marshal.ReleaseComObject(es); } } private static string GetPropertyName(Guid fmtid, IPropertyStorage propertyStorage, STATPROPSTG stg) { if (!string.IsNullOrEmpty(stg.lpwstrName)) return stg.lpwstrName; var propids = new int[1]; propids[0] = stg.propid; var names = new string[1]; names[0] = null; int hr = propertyStorage.ReadPropertyNames(1, propids, names); if (hr == 0) return names[0]; return null; } public void LoadProperties(Guid formatId) { IPropertySetStorage propertySetStorage; int hr = StgOpenStorageEx(FilePath, STGM.STGM_READ | STGM.STGM_SHARE_DENY_NONE | STGM.STGM_DIRECT_SWMR, STGFMT.STGFMT_ANY, 0, IntPtr.Zero, IntPtr.Zero, typeof(IPropertySetStorage).GUID, out propertySetStorage); if (hr == STG_E_FILENOTFOUND || hr == STG_E_PATHNOTFOUND) throw new FileNotFoundException(null, FilePath); if (hr != 0) throw new Win32Exception(hr); try { LoadPropertySet(propertySetStorage, formatId); } finally { Marshal.ReleaseComObject(propertySetStorage); } } private const int STG_E_FILENOTFOUND = unchecked((int)0x80030002); private const int STG_E_PATHNOTFOUND = unchecked((int)0x80030003); private const int STG_E_ACCESSDENIED = unchecked((int)0x80030005); private enum PRSPEC { PRSPEC_LPWSTR = 0, PRSPEC_PROPID = 1 } private enum STGFMT { STGFMT_ANY = 4, } [Flags] private enum STGM { STGM_READ = 0x00000000, STGM_READWRITE = 0x00000002, STGM_SHARE_DENY_NONE = 0x00000040, STGM_SHARE_DENY_WRITE = 0x00000020, STGM_SHARE_EXCLUSIVE = 0x00000010, STGM_DIRECT_SWMR = 0x00400000 } // we only define what we handle private enum VARTYPE : short { VT_I2 = 2, VT_I4 = 3, VT_R4 = 4, VT_R8 = 5, VT_CY = 6, VT_DATE = 7, VT_BSTR = 8, VT_DISPATCH = 9, VT_ERROR = 10, VT_BOOL = 11, VT_UNKNOWN = 13, VT_DECIMAL = 14, VT_I1 = 16, VT_UI1 = 17, VT_UI2 = 18, VT_UI4 = 19, VT_I8 = 20, VT_UI8 = 21, VT_INT = 22, VT_UINT = 23, VT_HRESULT = 25, VT_LPSTR = 30, VT_LPWSTR = 31, VT_FILETIME = 64, } [StructLayout(LayoutKind.Explicit)] private struct PROPVARIANTunion { [FieldOffset(0)] public sbyte cVal; [FieldOffset(0)] public byte bVal; [FieldOffset(0)] public short iVal; [FieldOffset(0)] public ushort uiVal; [FieldOffset(0)] public int lVal; [FieldOffset(0)] public uint ulVal; [FieldOffset(0)] public int intVal; [FieldOffset(0)] public uint uintVal; [FieldOffset(0)] public long hVal; [FieldOffset(0)] public ulong uhVal; [FieldOffset(0)] public float fltVal; [FieldOffset(0)] public double dblVal; [FieldOffset(0)] public short boolVal; [FieldOffset(0)] public int scode; [FieldOffset(0)] public long cyVal; [FieldOffset(0)] public double date; [FieldOffset(0)] public long filetime; [FieldOffset(0)] public IntPtr bstrVal; [FieldOffset(0)] public IntPtr pszVal; [FieldOffset(0)] public IntPtr pwszVal; [FieldOffset(0)] public IntPtr punkVal; [FieldOffset(0)] public IntPtr pdispVal; } [StructLayout(LayoutKind.Sequential)] private struct PROPSPEC { public PRSPEC ulKind; public PROPSPECunion union; } [StructLayout(LayoutKind.Explicit)] private struct PROPSPECunion { [FieldOffset(0)] public int propid; [FieldOffset(0)] public IntPtr lpwstr; } [StructLayout(LayoutKind.Sequential)] private struct PROPVARIANT { public VARTYPE vt; public ushort wReserved1; public ushort wReserved2; public ushort wReserved3; public PROPVARIANTunion union; } [StructLayout(LayoutKind.Sequential)] private struct STATPROPSTG { [MarshalAs(UnmanagedType.LPWStr)] public string lpwstrName; public int propid; public VARTYPE vt; } [StructLayout(LayoutKind.Sequential)] private struct STATPROPSETSTG { public Guid fmtid; public Guid clsid; public uint grfFlags; public System.Runtime.InteropServices.ComTypes.FILETIME mtime; public System.Runtime.InteropServices.ComTypes.FILETIME ctime; public System.Runtime.InteropServices.ComTypes.FILETIME atime; public uint dwOSVersion; } [DllImport("ole32.dll")] private static extern int StgOpenStorageEx([MarshalAs(UnmanagedType.LPWStr)] string pwcsName, STGM grfMode, STGFMT stgfmt, int grfAttrs, IntPtr pStgOptions, IntPtr reserved2, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, out IPropertySetStorage ppObjectOpen); [DllImport("ole32.dll")] private static extern int PropVariantClear(ref PROPVARIANT pvar); [Guid("0000013B-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] private interface IEnumSTATPROPSETSTG { [PreserveSig] int Next(int celt, ref STATPROPSETSTG rgelt, out int pceltFetched); // rest ommited } [Guid("00000139-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] private interface IEnumSTATPROPSTG { [PreserveSig] int Next(int celt, ref STATPROPSTG rgelt, out int pceltFetched); // rest ommited } [Guid("00000138-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] private interface IPropertyStorage { [PreserveSig] int ReadMultiple(uint cpspec, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] PROPSPEC[] rgpspec, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] PROPVARIANT[] rgpropvar); [PreserveSig] int WriteMultiple(uint cpspec, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] PROPSPEC[] rgpspec, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] PROPVARIANT[] rgpropvar, uint propidNameFirst); [PreserveSig] int DeleteMultiple(uint cpspec, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] PROPSPEC[] rgpspec); [PreserveSig] int ReadPropertyNames(uint cpropid, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] int[] rgpropid, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 0)] string[] rglpwstrName); [PreserveSig] int NotDeclared1(); [PreserveSig] int NotDeclared2(); [PreserveSig] int Commit(uint grfCommitFlags); [PreserveSig] int NotDeclared3(); [PreserveSig] int Enum(out IEnumSTATPROPSTG ppenum); // rest ommited } [Guid("0000013A-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] private interface IPropertySetStorage { [PreserveSig] int Create([MarshalAs(UnmanagedType.LPStruct)] Guid rfmtid, [MarshalAs(UnmanagedType.LPStruct)] Guid pclsid, uint grfFlags, STGM grfMode, out IPropertyStorage ppprstg); [PreserveSig] int Open([MarshalAs(UnmanagedType.LPStruct)] Guid rfmtid, STGM grfMode, out IPropertyStorage ppprstg); [PreserveSig] int NotDeclared3(); [PreserveSig] int Enum(out IEnumSTATPROPSETSTG ppenum); } } public sealed class StructuredProperty { public StructuredProperty(Guid formatId, string name, int id) { FormatId = formatId; Name = name; Id = id; } public Guid FormatId { get; private set; } public string Name { get; private set; } public int Id { get; private set; } public object Value { get; set; } public override string ToString() { return Name; } }

Podría haber un enfoque más genérico. Si su fuente es un archivo ... x, el documento se puede extraer mediante consultas XML. Si descomprime el archivo (por ejemplo, con 7-Zip), encontrará un archivo llamado custom.xml en la subcarpeta docProps. Las propiedades se pueden encontrar fácilmente dentro del archivo XML

<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"> <property fmtid="{D5CDD505-2E9C-101B-9397-08002B2CF9AE}" pid="2" name="SAPDOKNR"> <vt:lpwstr>10002210058</vt:lpwstr> </property> ...

Puede probar el motor NPOI para extraer propiedades de diferentes archivos de Office (doc, xls, xlsx, docx, etc.). Este componente no tiene dependencias de terceros y no necesita Office para usarlo.

Sin embargo, esta biblioteca es un poco complicada porque necesita usar diferentes tipos de extractores de propiedades para diferentes tipos de archivos. Un buen ejemplo de código se puede encontrar en el repositorio oficial de Git Hub TestHPSFPropertiesExtractor .

El paquete NuGet se puede encontrar here .