Top-Themen

AppleEntwicklungHardwareInternetLinuxMicrosoftMultimediaNetzwerkeOff TopicSicherheitSonstige SystemeVirtualisierungWeiterbildungZusammenarbeit

Aktuelle Themen

Administrator.de FeedbackApache ServerAppleAssemblerAudioAusbildungAuslandBackupBasicBatch & ShellBenchmarksBibliotheken & ToolkitsBlogsCloud-DiensteClusterCMSCPU, RAM, MainboardsCSSC und C++DatenbankenDatenschutzDebianDigitiales FernsehenDNSDrucker und ScannerDSL, VDSLE-BooksE-BusinessE-MailEntwicklungErkennung und -AbwehrExchange ServerFestplatten, SSD, RaidFirewallFlatratesGoogle AndroidGrafikGrafikkarten & MonitoreGroupwareHardwareHosting & HousingHTMLHumor (lol)Hyper-VIconsIDE & EditorenInformationsdiensteInstallationInstant MessagingInternetInternet DomäneniOSISDN & AnaloganschlüsseiTunesJavaJavaScriptKiXtartKVMLAN, WAN, WirelessLinuxLinux DesktopLinux NetzwerkLinux ToolsLinux UserverwaltungLizenzierungMac OS XMicrosoftMicrosoft OfficeMikroTik RouterOSMonitoringMultimediaMultimedia & ZubehörNetzwerkeNetzwerkgrundlagenNetzwerkmanagementNetzwerkprotokolleNotebook & ZubehörNovell NetwareOff TopicOpenOffice, LibreOfficeOutlook & MailPapierkorbPascal und DelphiPeripheriegerätePerlPHPPythonRechtliche FragenRedHat, CentOS, FedoraRouter & RoutingSambaSAN, NAS, DASSchriftartenSchulung & TrainingSEOServerServer-HardwareSicherheitSicherheits-ToolsSicherheitsgrundlagenSolarisSonstige SystemeSoziale NetzwerkeSpeicherkartenStudentenjobs & PraktikumSuche ProjektpartnerSuseSwitche und HubsTipps & TricksTK-Netze & GeräteUbuntuUMTS, EDGE & GPRSUtilitiesVB for ApplicationsVerschlüsselung & ZertifikateVideo & StreamingViren und TrojanerVirtualisierungVisual StudioVmwareVoice over IPWebbrowserWebentwicklungWeiterbildungWindows 7Windows 8Windows 10Windows InstallationWindows MobileWindows NetzwerkWindows ServerWindows SystemdateienWindows ToolsWindows UpdateWindows UserverwaltungWindows VistaWindows XPXenserverXMLZusammenarbeit

C Sharp - Extensions

Anleitung Entwicklung C und C++

Mitglied: Blueberry

Blueberry (Level 1) - Jetzt verbinden

07.02.2012, aktualisiert 24.02.2012, 6528 Aufrufe, 2 Kommentare, 1 Danke

In dieser kleinen Anleitung, möchte ich zeigen, was Extensions sind und wie man sie unter C# einsetzt.
Beiläufig wird es noch Typen-Konvertierungen beinhalten, damit das auch mal geklärt ist.

Extension Method - Was ist das?
Mittels einer extension Method kann man einen Datentyp erweitern, d.h. wenn ich eine extension Method für den Datentyp String definiere, kann man darauf zugreifen, als ob man auf eine andere schon vorhandene bzw. schon in der String-Class implementierte Methode zugreift.

Bedingungen einer extension Method
Um eine extension Method zu schreiben, muss man lediglich ein paar Kleinigkeiten beachten:
    • Die Klasse in der die Methode geschrieben wird, muss statisch sein
    • Die Methode selbst muss auch statisch sein
    • Der erste Parameter muss vom entsprechenden Datentype sein und muss mit this versehen sein (siehe unter Implementierung)
    • Man braucht dazu mind. das .NET-Framework 3.5 (oder höher selbstverständlich)

Implementierung
Hier ein paar Beispiele

Unter dem Code gibt es noch eine Erklärung
01.
using System; 
02.
using System.IO; 
03.
using System.Text; 
04.
 
05.
namespace Basics 
06.
07.
    public static class Converter 
08.
09.
        /// <summary> 
10.
        /// Konvertiert einen String in einen Int32. 
11.
        /// </summary> 
12.
        /// <param name="str">Input-Parameter</param> 
13.
        /// <returns>In Int32 konvertierter String</returns> 
14.
        /// <exception cref="FormatException">Tritt auf, wenn der String nicht erlaubte zeichen beinhaltet</exception> 
15.
        /// <exception cref="OverflowException">Tritt auf, wenn die Zahl zu gross ist</exception> 
16.
        public static int ToInt32(this String str) 
17.
18.
            return Convert.ToInt32(str); 
19.
20.
 
21.
        /// <summary> 
22.
        /// Konvertiert einen String in einen Int32. 
23.
        /// Bei einer Exception wird die Default-Value zurückgegeben. 
24.
        /// </summary> 
25.
        /// <param name="str">Input-Parameter</param> 
26.
        /// <param name="defValue">Default-Value</param> 
27.
        /// <returns>In Int32 konvertierter String</returns> 
28.
        public static int ToInt32(this String str, Int32 defValue) 
29.
30.
            try 
31.
32.
                return ToInt32(str); 
33.
34.
            catch (Exception) 
35.
36.
                return defValue; 
37.
38.
39.
 
40.
        /// <summary> 
41.
        /// Konvertiert einen String in einen bool. 
42.
        /// </summary> 
43.
        /// <param name="str">Input-Parameter</param> 
44.
        /// <returns>Converted String bool</returns> 
45.
        public static bool ToBool(this String str) 
46.
47.
            switch(str.ToLower()) 
48.
49.
                case "1": 
50.
                case "true": 
51.
                case "yes": 
52.
                    return true; 
53.
                case "0": 
54.
                case "false": 
55.
                case "no": 
56.
                    return false; 
57.
                default: 
58.
                    throw new FormatException("Kann nicht konvertiert werden."); 
59.
60.
61.
62.
}
Hier sieht man den gesamten Aufbau, die statische Klasse, die statische Methoden und auch die mit dem this versehenen Parameter. Man sieht in der ToInt32-Überladung, dass man auch auf extension Methoden in einer Extension zugreifen kann. Dass ermöglicht einem, dass man auch bei extension Methoden nichts zwei Mal implementieren muss. Die ToBool-Methode finde ich vorallem sehr praktisch, da man diese ganz einfach erweitern kann. Man könnte z.B. auch eine CSV exportieren und dort diese für den Benutzer bereitstellen, so kann er selbst entscheiden, was true oder false ergeben soll.

Man kann auch Generics verwenden und die Extensions sind nicht nur auf die Basis-Typen anwendbar:
01.
        /// <summary> 
02.
        /// Konvertiert ein byte-Array in einen string 
03.
        /// </summary> 
04.
        /// <param name="arr">Input-Parameter</param> 
05.
        /// <returns>String welcher aus dem Byte-Array konvertiert wurde</returns> 
06.
        public static string GetString<T>(this byte[] arr) where T: Encoding, new() 
07.
08.
            return new T().GetString(arr); 
09.
10.
 
11.
        /// <summary> 
12.
        /// Liest einen Stream aus und gibt die Daten zurück. 
13.
        /// Seek-Unabhängige Methode. 
14.
        /// </summary> 
15.
        /// <param name="stream"></param> 
16.
        /// <param name="initSize"></param> 
17.
        /// <returns></returns> 
18.
        public static byte[] GetData(this Stream stream, int initSize) 
19.
20.
            if (stream == null) 
21.
                throw new ArgumentNullException("stream"); 
22.
 
23.
            //Überprüfen, ob man den Stream lesen kann. 
24.
            if (!stream.CanRead) 
25.
                throw new ArgumentException("Stream kann nicht gelesen werden!"); 
26.
 
27.
            if (initSize < 1) 
28.
                initSize = 128; 
29.
 
30.
            byte[] buffer = new byte[initSize]; 
31.
            int currByte, count = 0; 
32.
 
33.
            while((currByte = stream.ReadByte()) != -1) 
34.
35.
                buffer[count] = (byte)currByte; 
36.
                count++; 
37.
 
38.
                if(count == buffer.Length - 1) 
39.
40.
                    byte[] tmpBuffer = buffer; 
41.
                    buffer = new byte[tmpBuffer.Length * 2]; 
42.
                    tmpBuffer.CopyTo(buffer, 0); 
43.
44.
45.
             
46.
            Array.Resize(ref buffer, count); 
47.
 
48.
            return buffer; 
49.
50.
 
51.
        /// <summary> 
52.
        /// Konvertiert die Daten eines Streams in einen string mit dem angegebenen Encoding. 
53.
        /// </summary> 
54.
        /// <param name="stream">Input Stream</param> 
55.
        /// <returns>Gibt den stream in dem gewünschten Format zurück</returns> 
56.
        public static string GetStringData<T>(this Stream stream) where T : Encoding, new() 
57.
58.
            return stream.GetData().GetString<T>(); 
59.
        }
Mit solchen Extensions könnt ihr gut konvertierungen machen und müsst nicht mehr gross an die Typen-Konvertierung denken, wenn ihr am Arbeiten seid. Natürlich könnt ihr auch andere Funktionalitäten, welche nicht unbedingt eine Type-Konvertierung brauchen mittels Extensions implementieren, allerdings habe ich dafür noch nicht wirklich anwendung gefunden...

Edit: Habe jetzt auch schon eine Extension, welche nicht unbedingt eine Typen-Konvertierung beinhaltet.
Es geht dabei um eine Extension, welche tatsächlich neue Funktionalität zur Verfügung stellt. Die unten gezeigte Extension greift auf die User32.dll zu und ändert den Status der ProgressBar, damit man trotz aktiven Visual-Styles eine rote ProgressBar hinbekommt, ich konnte diese Methoden schon öfters gebrauchen.

01.
        #region Progressbar 
02.
 
03.
        #region Enum & Constants 
04.
        public enum ProgressBarState : int 
05.
06.
            NORMAL = 1, 
07.
            ERROR = 2, 
08.
            PAUSED = 3, 
09.
10.
 
11.
        public const int WM_USER = 0x400; 
12.
        public const int PBM_SETSTATE = WM_USER + 16; 
13.
        public const int PBM_GETSTATE = WM_USER + 17; 
14.
 
15.
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)] 
16.
        static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam); 
17.
         
18.
        #endregion 
19.
 
20.
        #region Methods 
21.
 
22.
        public static ProgressBarState GetState(this ProgressBar pBar) 
23.
24.
            return (ProgressBarState)(int)SendMessage(pBar.Handle, PBM_GETSTATE, IntPtr.Zero, IntPtr.Zero); 
25.
26.
 
27.
        public static void SetState(this ProgressBar pBar, ProgressBarState state) 
28.
29.
            SendMessage(pBar.Handle, PBM_SETSTATE, (IntPtr)state, IntPtr.Zero); 
30.
            //Die folgende Zeile sorgt dafür, dass alle Messages (z.B. die von oben) verarbeitet werden und erst dann weiter gemacht wird. 
31.
            Application.DoEvents(); 
32.
33.
 
34.
        #endregion 
35.
 
36.
        #endregion 
37.
 
Ich hoffe das Tut konnte euch etwas veranschaulichen, was eine Extension ist und wie man sie implementiert und anwendet.
Über Feedback und Kritik freue ich mich immer, allerdings ist es mein erstes Tut welches ich schreibe, seid also nicht zu hart zu mir .
Wenn ihr Verbesserungsvorschläge habt, dann sagt mir unbedingt bescheid!

Edit: Stream-Extension 'GetData' Seek-Unabhängig implementiert.
Mitglied: Herbrich19
20.02.2012, aktualisiert 21.02.2012
Kann ich zwar in Moment nicht wirklich gebrauchen, aber sehr schön übersichtlich. Ich werde unbedingt mal eine kleine Test-App schreiben und es mal testen, aber so kann man sich wirklich die Arbeit an den Konvertierungen sehr stark vereinfachen.

Grüße, Herbrich17
Bitte warten ..
Mitglied: Blueberry
22.02.2012 um 16:13 Uhr
Hallo Herbrich17

Vielen Dank für dein Feedback!
Ich habe mittlerweilen auch eine Extension geschrieben, welche nicht nur für Typen-Konvertierung geeignet ist, ich habe (bzw. werde) diese oben im Beitrag noch erweitern zum zeigen, dass man die Extensions auch für andere Sachen gebrauchen kann.

Gruss Blueberry
Bitte warten ..
Neuester Wissensbeitrag
Windows 10

Powershell 5 BSOD

(8)

Tipp von agowa338 zum Thema Windows 10 ...

Ähnliche Inhalte
Visual Studio
gelöst C-Sharp WPF Controls und Extensions (3)

Frage von mayho33 zum Thema Visual Studio ...

Visual Studio
C-Sharp WPF Binding TextBox.Text und Property MVVM (die 2.) (4)

Frage von mayho33 zum Thema Visual Studio ...

Windows Server
C sharp oder Powershell oder VB? (3)

Frage von 1410640014 zum Thema Windows Server ...

Heiß diskutierte Inhalte
Microsoft
Ordner mit LW-Buchstaben versehen und benennen (20)

Frage von Xaero1982 zum Thema Microsoft ...

Outlook & Mail
gelöst Outlook 2010 findet ost datei nicht (19)

Frage von Floh21 zum Thema Outlook & Mail ...

Netzwerkmanagement
gelöst Anregungen, kleiner Betrieb, IT-Umgebung (18)

Frage von Unwichtig zum Thema Netzwerkmanagement ...