[ExtensionMethods] Verschiedene

Beschreibung:

Ich bin immer auf der Suche nach hilfreichen Extension-Methods. Aber da man nicht allzuviele (bzw. immer wieder die gleichen) über Google und Co findet, hab ich mir gedacht, man könnte hier eine kleine Sammlung von Extension Methods aufmachen, zu der jeder gute und hilfreiche Extensionmethods hinzufügen kann.

Weitere Threads mit Extension Methods:
String
Reflection
IEnumerable

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;

namespace ExtensionLibrary
{
    public static class VariousExtensionMethods
    {
        // Extensions Methods
        #region +^ GetTypeConverter(this Type type)

        /// <summary>
        /// Gets the type converter bound to the passed type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public static TypeConverter GetTypeConverter(this Type type)
        {
            if (type.IsAttributeDefined<TypeConverterAttribute>())
            {
                return (TypeConverter) Activator.CreateInstance(Type.GetType (type.GetCustomAttribute<TypeConverterAttribute> ().ConverterTypeName));
            }
            return null;
        }

        #endregion
        #region +^ SerializeToStream(this Object obj, Stream stream)

        /// <summary>
        /// Serializes the specified object to the specified stream.
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <param name="stream">The stream.</param>
        public static void SerializeToStream(this Object obj, Stream stream)
        {
            new BinaryFormatter().Serialize(stream, obj);
            stream.Position = 0;
        }

        #endregion
    }
}

Ich hoffe, es werden sich viele beteiligen, damit die Sammlung auch einen guten Umfang bekommt.

Gruß, Christian.

EDIT
Auf Bitte von herbivore verscheidene Threads mit verschiedenen ExtensionMethodsGruppen

Schlagwörter: Extension Methods Extensionmethods Sammlung

        /// <summary>  
        /// Determines whether the specified string is null or empty.  
        /// </summary>  
        /// <param name="s">The string.</param>  
        /// <returns>  
        ///     <c>true</c> if the string is null or empty; otherwise, <c>false</c>.  
        /// </returns>  
        public static Boolean IsNullOrEmpty(this String s)  
        {  
            return s == null || s.Trim().Length == 0;  
        }  

IsNullOrEmpty ist quatsch, würde trotz NULL zwar funktionieren, ist aber aus meiner Sicht unlogisch und sollte nicht funktionieren dürfen, da eindeutig Null-Reference und da mit String.IsNullOrEmpty bereits eine gleichwertige Methode existiert.

Edit: Beitrag in [ExtensionMethods] Reflection hinzugefügt

@JunkyXL:

Da hast du natürlich recht, siehe hier. Aber mit String.IsNullOrEmpty() wäre es nur gleichwertig, wenn das Trim() nicht dabei wäre!

@xxxprod:

Die GetReflected(), SetReflected() und GetProperty() Methoden kann ich sehr gut gebrauchen. Gute Idee, Gute Umsetzung! Danke!
Zum Thema einzeln posten: Kann ich nachvollziehen, aber für jede ExtensionMethod einen eigenen Thread zu erstellen finde ich erstens zu viele Threads und zweitens unübersichtlich, wenn man alle durchsehen möchte. Und eine (zwar kurze) Beschreibung ist ja auch in den XML-Kommentaren drin.

Gruß, Christian.

Zu der GetTypeConverter Extensionmethod, die ist im Prinzip gleichwertig zu TypeDescriptor.GetConverter(). Außerdem weiß ich nicht, wie MS das implementiert hat, ob die evtl einen Cache der TypeConverter halten. Aber sei es wie es sei, die durchgängige Benutzung von der Framework-Variante kann eigentlich fast nur Vorteile bringen...

@onlinegurke:

Wieder was dazugelernt. Wie schon sehr oft festgestellt:

Programmieren ist die einfachste Sache der Welt, wenn man die Klassen kennt, die das, was man grade programmiert, schon fertig implementiert haben....

TypeDescriptor.GetConverter() kannte ich noch nicht, und natürlich ist diese Methode meiner vorzuziehen, da x-mal getestet, viel benutzt und deswegen besser.

Gruß, Christian

      /// <remarks>
      /// "unendliche" readStreams (z.B. System.Net.Sockets.Networkstream) müssen mit der 
      /// anderen Überladung kopieren
      /// </remarks>
      public static void WriteTo(this Stream readStream, Stream writeStream) {
         byte[] buf = new byte[short.MaxValue];
         while (true) {
            int portion = readStream.Read(buf, 0, short.MaxValue);
            if (portion == 0) return;
            writeStream.Write(buf, 0, portion);
         }
      }

      public static void WriteTo(this Stream readStream, Stream writeStream, long bytesToRead) {
         byte[] buf = new byte[short.MaxValue];
         while (bytesToRead != 0) {
            int portion = readStream.Read(buf, 0, short.MaxValue);
            if (portion == 0) throw new ArgumentException(
               "Die geforderte Anzahl Bytes konnte nicht aus dem Lese-Stream gelesen werden",
               "readStream + bytesToRead");
            bytesToRead -= portion;
            writeStream.Write(buf, 0, portion);
         }
      }

         using (FileStream reader = new FileStream("Test.txt", FileMode.Open)) {
            using (FileStream writer = new FileStream("Test2.txt", FileMode.Create)) {
               reader.WriteTo(writer);
            }
         }

mit FileStream is jetzt kein wirklich gutes Beispiel, mit GZipStream oder den Streams einer WebResponse isses interessanter.

      public static void Raise(this EventHandler Event, object sender){
         if (Event != null) { Event(sender, EventArgs.Empty); }
      }
      public static void Raise<T>(this EventHandler<T> Event, object sender, T e) where T : EventArgs {
         if (Event != null) { Event(sender, e); }
      }

Das sieht jetzt aus wie perfektionierte Schreibfaulheit, aber 's kann Code wirklich leserlicher machen, wenn statt 3 Zeilen nur noch eine gebraucht wird:

         OnChatMessage = delegate(MessageEventargs e) { ChatMessage.Raise(this, e); };
         OnStatusMessage = delegate(MessageEventargs e) { StatusMessage.Raise(this, e); };

Habe ich gerade erstellt, da ich es mal eben gebraucht habe und bei Assembly und Type nicht gefunden habe (vllt. habe ich den passenden Namen nicht erkannt).

Jedenfalls hier eine Methode um auf dem Typ alle vererbten Typen zurückzugeben.
Jedoch nur innerhalb der Assembly, die den übergebenen Typ enthält.
Könnte man auf alle geladenen Assemblies ausweiten, was aber möglicherweise lange dauern könnte. Wer es so braucht, kann das entsprechend erweitern.

/// <summary>
/// Returns an array of types which derive from the specified type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Type[] GetDerivedTypes(this Type type)
{
    List<Type> types = new List<Type>();
    foreach (Type type2 in Assembly.GetAssembly(type).GetTypes())
    {
        if (type2.IsSubclassOf(type))
        {
            types.Add(type2);
        }
    }
    return types.ToArray();
}