Feedback

C# - MIMETypeManager

Veröffentlicht von am 27.10.2008
(1 Bewertungen)
Diese Klasse ermittelt aus der Registry alle (alle die eine Beschreibung besitzen) Dateinamenserweiterungen inkl. deren Beschreibungen und icons im Format 32x32 Pixel und gibt sie als generische Liste der Klasse mimetype zurück.
Die Klasse verfügt auch über Funktionen zum Speichern und Wiederherstellen der Liste ohne Registryzugriff und auch Funktionen um einzelne mimetypes anhand deren Dateinamenserweiterung abzufragen.

Das Wiederherstellen der Liste aus der erzeugten Textdatei funktioniert zwar, ist jedoch qualitativ nicht zufriedenstellend. ( Hoffe ihr könnt mir damit helfen )

PS: vergesst nicht, wenn ihr das Projekt erstellen wollt, die benötigten Default-Icons als Resource im Projekt zu speichern.


GFU-Schulungen  [Anzeige]

VB.NET 2017/2015/2013 Aufbau

Nach dieser Schulung können Sie mittels objektorientierter Modelle in VB.NET 2017/2015/2013 wiederverwendbare Elemente eigenständig erstellen.

C# Aufbaukurs

Sie haben grundlegende .NET- und C#-Kenntnisse und und wollen diese nun erweitern. Der Aufbaukurs C# führt Sie ein die Arbeit mit Interfaces und Delegates, Generics und Parallel Computing.

#region Win32 Klassen
using System;
using System.Runtime.InteropServices;
using System.Drawing;
using MimetypeHelper.Properties;

/// <summary> Summary description for NativeIcon.</summary>
public class NativeIcon
{
    #region WIN32

    [DllImport("shell32.dll", CharSet = CharSet.Auto)]
    private static extern int SHGetFileInfo(
      string pszPath,
      int dwFileAttributes,
      out    SHFILEINFO psfi,
      uint cbfileInfo,
      SHGFI uFlags);

    /// <summary>Maximal Length of unmanaged Windows-Path-strings</summary>
    private const int MAX_PATH = 260;
    /// <summary>Maximal Length of unmanaged Typename</summary>
    private const int MAX_TYPE = 80;

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    private struct SHFILEINFO
    {
        public SHFILEINFO(bool b)
        {
            hIcon = IntPtr.Zero;
            iIcon = 0;
            dwAttributes = 0;
            szDisplayName = "";
            szTypeName = "";
        }
        public IntPtr hIcon;
        public int iIcon;
        public uint dwAttributes;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
        public string szDisplayName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_TYPE)]
        public string szTypeName;
    };

    private NativeIcon()
    {
    }

    [Flags]
    enum SHGFI : int
    {
        /// <summary>get icon</summary>
        Icon = 0x000000100,
        /// <summary>get display name</summary>
        DisplayName = 0x000000200,
        /// <summary>get type name</summary>
        TypeName = 0x000000400,
        /// <summary>get attributes</summary>
        Attributes = 0x000000800,
        /// <summary>get icon location</summary>
        IconLocation = 0x000001000,
        /// <summary>return exe type</summary>
        ExeType = 0x000002000,
        /// <summary>get system icon index</summary>
        SysIconIndex = 0x000004000,
        /// <summary>put a link overlay on icon</summary>
        LinkOverlay = 0x000008000,
        /// <summary>show icon in selected state</summary>
        Selected = 0x000010000,
        /// <summary>get only specified attributes</summary>
        Attr_Specified = 0x000020000,
        /// <summary>get large icon</summary>
        LargeIcon = 0x000000000,
        /// <summary>get small icon</summary>
        SmallIcon = 0x000000001,
        /// <summary>get open icon</summary>
        OpenIcon = 0x000000002,
        /// <summary>get shell size icon</summary>
        ShellIconSize = 0x000000004,
        /// <summary>pszPath is a pidl</summary>
        PIDL = 0x000000008,
        /// <summary>use passed dwFileAttribute</summary>
        UseFileAttributes = 0x000000010,
        /// <summary>apply the appropriate overlays</summary>
        AddOverlays = 0x000000020,
        /// <summary>Get the index of the overlay in the upper 8 bits of the iIcon</summary>
        OverlayIndex = 0x000000040,
    }

    #endregion

    /// <summary>
    /// Get the associated Icon for a file or application, this method always returns
    /// an icon.  If the strPath is invalid or there is no idonc the default icon is returned
    /// </summary>
    /// <param name="strPath">full path to the file</param>
    /// <param name="bSmall">if true, the 16x16 icon is returned otherwise the 32x32</param>
    /// <returns></returns>
    public static Icon GetIcon(string strPath, bool bSmall)
    {
        try
        {
            SHFILEINFO info = new SHFILEINFO(true);
            int cbFileInfo = Marshal.SizeOf(info);
            SHGFI flags;
            if (bSmall)
                flags = SHGFI.Icon | SHGFI.SmallIcon | SHGFI.UseFileAttributes;
            else
                flags = SHGFI.Icon | SHGFI.LargeIcon | SHGFI.UseFileAttributes;

            SHGetFileInfo(strPath, 0, out info, (uint)cbFileInfo, flags);
            return Icon.FromHandle(info.hIcon);
        }
        catch (Exception)
        {
            // dann ist bei der Extrahierung was schief gegangen und wir geben das Default Icon zurück ..
            return Resources.undefined;
        }

    }

}


#endregion

#region Dateityp Klasse

namespace MimetypeHelper
{
    /// <summary>
    /// Diese Klasse stellt einen Dateityp dar.
    /// Sie besitzt die Eigenschaften der Erweiterung, die 'Content Type' Beschreibung und das zugehörige Icon im Format 32x32 Pixel.
    /// (C) Patrick Sperneder 2008
    /// </summary>
    public class mimetype
    {
        #region Member

        private System.Drawing.Icon ico;
        private string mime;
        private string extension;

        #endregion

        #region Konstruktor

        public mimetype(System.Drawing.Icon i, string m, string ext)
        {
            this.ico = i;
            this.mime = m;
            this.extension = ext;
        }

        #endregion

        #region Props

        public System.Drawing.Icon MimeIcon { get { return this.ico; } }
        public string MimeTypeString { get { return this.mime; } }
        public string Extension { get { return this.extension; } }
        #endregion
    }
}


#endregion

#region Dateitypen Manager Klasse

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using Microsoft.Win32;
using MimetypeHelper.Properties;

namespace MimetypeHelper
{
    /// <summary>
    /// Diese Klasse liest aus der Registry alle registrierten Dateitypen die eine Inhaltsbeschreibung haben
    /// und ermittelt deren Icons und stellt dies in einer generischen Liste zur Verfügung.
    /// TODO : Das Laden der Icons aus der erstellten Textliste (aus Performance Gründen ) , ist qualitativ nicht zufriedenstellend.
    /// Derzeit wird bei jeder Instanzierung dieser Klasse, die Dateitypen neu erstellt. (Bug#TODO#1710)
    /// (C) Sperneder Patrick 2008.
    ///  Wenn Ihr die Klasse gut findet, wäre ich für ein paar Punkte dankbar.
    /// </summary>
    public class MimetypePool
    {
        #region Member

        private const string MIME_RESSOURCE_FILE = "MIME.TYPES";
        private List<mimetype> types;

        #endregion

        #region Konstruktor

        public MimetypePool()
        {
            if (!IsMimeListStored())
            {
                this.types = GetMimetypes();
                // nachdem wir sie jetzt aufwändig erzeugt haben,
                // ersparen wir uns das beim nächsten mal und speichern sie lokal ab.
                StoreMimeList();
            }
            else
            {
                // die icons sehen einfach nicht schön aus !
                //this.types = RestoreMimeList();
                this.types = GetMimetypes();
            }
        }


        #endregion

        #region Speichern Laden der Liste

        /// <summary>
        /// Überprüft ob die Liste vorhanden ist oder nicht.
        /// </summary>
        /// <returns></returns>
        private bool IsMimeListStored()
        {
            if (File.Exists(MIME_RESSOURCE_FILE))
                return true;
            else
                return false;
        }

        /// <summary>
        /// Speichert die Mimeliste im Pfad der Anwendung ab, um neues erstellen zu vermeiden.
        /// </summary>
        private void StoreMimeList()
        {
            StringBuilder flbuild = new StringBuilder();
            foreach (mimetype m in this.types)
            {
                flbuild.AppendLine(IconToBase64String(m.MimeIcon) + ";" + m.MimeTypeString + ";" + m.Extension);
            }
            File.WriteAllText(MIME_RESSOURCE_FILE, flbuild.ToString());
        }

        /// <summary>
        /// Erstellt aus der Datei eine neue MIMEListe im Pfad der Anwendung..
        /// </summary>
        /// <returns></returns>
        private List<mimetype> RestoreMimeList()
        {
            try
            {
                List<mimetype> m = new List<mimetype>();

                string[] lines = File.ReadAllLines(MIME_RESSOURCE_FILE);
                foreach (string line in lines)
                {
                    string[] pcs = line.Split(new char[] { ';' });

                    m.Add(new mimetype(IconFromBase64String(pcs[0]), pcs[1], pcs[2]));
                }
                return m;
            }
            catch (Exception)
            {
                return GetDefaultListOnError();
            }
        }

        /// <summary>
        /// Sollte bei der Ermittlung der Dateitypen etwas schief gelaufen sein,
        /// so wird diese liste mit den Dateitypen und deren icons zurückgegeben.
        /// (Zwar nicht vollständig, aber ausreichend im Fehlerfall)
        /// </summary>
        /// <returns></returns>
        private List<mimetype> GetDefaultListOnError()
        {
            List<mimetype> m = new List<mimetype>();
            m.Add(new mimetype(Resources.doc, "Microsoft Word Document", ".doc"));
            m.Add(new mimetype(Resources.jpg, "JPG image", ".jpg"));
            m.Add(new mimetype(Resources.zip, "Compressed archive", ".zip"));
            // ...
            return m;
        }

        #endregion

        #region Erzeugen der Liste

        /// <summary>
        /// Erstellt die generische Liste mit den Dateitypen auf dem Rechner.
        /// </summary>
        /// <returns></returns>
        private List<mimetype> GetMimetypes()
        {
            List<mimetype> ret = new List<mimetype>();
            try
            {
                //alle vorhandenen Dateitypen durchsuchen. 
                foreach (string key in Registry.ClassesRoot.GetSubKeyNames())
                {
                    // nur extensions ...
                    if (key.StartsWith("."))
                    {
                        // nur wenn der Datei auch ein Icon zugeordnet ist.
                        if (HasAssociatedIcon(GetExtensionDefaultValue(key)))
                        {
                            ret.Add(new mimetype(NativeIcon.GetIcon(key, false), GetExtensionDisplayDescription(GetExtensionDefaultValue(key)), key));
                        }
                    }
                }

                return ret;
            }
            catch (Exception)
            {
                return GetDefaultListOnError();
            }
        }

        /// <summary>
        /// Gibt den Wert des (Default) Wertes eines Registry Schlüssels zurück.
        /// </summary>
        /// <param name="Extension">Die Extension mit führendem Punkt. z.B .txt ...</param>
        /// <returns>Die Beschreb</returns>
        private string GetExtensionDefaultValue(string Extension)
        {
            string def = (string)Registry.ClassesRoot.OpenSubKey(Extension).GetValue("");

            if (def == null || def == string.Empty)
                return "n";
            else
                return def;
        }

        /// <summary>
        /// Gibt zurück ob dieser Endung ein Icon zugeordnet ist oder nicht.
        /// </summary>
        /// <param name="ExtensionDefaultValue">Der Standard Wert der Erweiterung</param>
        /// <returns></returns>
        private bool HasAssociatedIcon(string ExtensionDefaultValue)
        {
            try
            {
                if (ExtensionDefaultValue == "n")
                    return false;
                // Überprüfen ob der Schlüssel überhaupt vorhanden ist ..
                if (Registry.ClassesRoot.OpenSubKey(ExtensionDefaultValue) != null)
                {
                    if (Registry.ClassesRoot.OpenSubKey(ExtensionDefaultValue).OpenSubKey("defaulticon") == null)
                        return false;
                    else
                        return true;
                }
                else
                    return false;
            }
            catch (Exception)
            {
                return false;
            }

        }

        /// <summary>
        /// Gibt die Klartext-Beschreibung der Extension zurück. für z.b (.txt) Word Textdokument ...)
        /// </summary>
        /// <param name="ExtensionDefaultValue">Der Defaultwert eines extension Schlüssel</param>
        /// <returns></returns>
        private string GetExtensionDisplayDescription(string ExtensionDefaultValue)
        {
            if (ExtensionDefaultValue == "n")
                return "n";
            string desc = (string)Registry.ClassesRoot.OpenSubKey(ExtensionDefaultValue).GetValue("");

            if (desc == null || desc == string.Empty)
            {
                return "keine Beschreibung";
            }
            else
            {
                return desc;
            }
        }

        #endregion

        #region Zusatzfunktionen



        public Icon IconFromBase64String(string base64)
        {
            MemoryStream memory = new MemoryStream(Convert.FromBase64String(base64));
            Icon result = new Icon(memory, new Size(32, 32));
            memory.Close();
            return result;
        }

        public string IconToBase64String(Icon image)
        {
            MemoryStream memory = new MemoryStream();
            image.Save(memory);
            string base64 = Convert.ToBase64String(memory.ToArray());
            memory.Close();

            return base64;
        }

        #endregion

        #region Methoden

        /// <summary>
        /// Gibt das Objekt das der Dateinamenserweiterung entspricht zurück.
        /// </summary>
        /// <param name="Extension">Die Dateinamenserweiterung der Datei inklusive führenedem Punkt. z.B .txt</param>
        /// <returns>Bei Erfolg das Objekt, andernfalls nix.</returns>
        public mimetype GetTypeByExtension(string Extension)
        {
            Extension = Extension.ToLower();

            for (int i = this.types.Count - 1; i >= 0; i--)
            {
                if (types[i].Extension == Extension)
                {
                    return types[i];
                }
            }
            // wenn wir nichts finden, geben wir einen unbekannten Dateitypen zurück
            return new mimetype(Resources.undefined, "unbekannte Datei", "???");

        }

        /// <summary>
        /// Gibt das Symbol für einen Ordner zurück
        /// </summary>
        /// <returns></returns>
        public mimetype GetFolder()
        {
            return new mimetype(Resources.folder, "Ordner", "keine");
        }

        /// <summary>
        /// Gibt das Symbol für einen Link zurück
        /// </summary>
        /// <returns></returns>
        public mimetype GetLink()   
        {
            return new mimetype(Resources.link , "Link", "Verknüpfung");
        }

        #endregion

        #region Eigenschaften

        /// <summary>
        /// Gibt alle Dateitypen die eine Beschreibung haben zurück. (andernfalls eine standardliste)
        /// </summary>
        public List<mimetype> MimeTypes { get { return this.types; } }

        #endregion
    }
}



#endregion

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!