public class ProductReference
{
        public string StaticName { get { return "ProductReference"; } }
        public string DisplayName { get { return Resources.Displayname_ProductReference; } }
        public Guid ID { get { return new Guid("{6ebe0f28-af6a-40f7-9ad8-d9ff37d2b045}"); } }
        public string TypeName { get { return "String"; } }
        public Type Type { get { return typeof(String); } }
        public String Value { get; set; }
	public bool ErrorsDetected { get; set; }
}
public class Item
{
	public ProductReference ProductReference { get; set; }
}

Jetzt soll dieser Datentyp natürlich auch irgendwo gespeichert werden. In meinem Fall ist es einfach eine SharePoint Liste bei der jedes Feld einer Klasseneigenschaft entspricht. (Das Speichern reicht natürlich nicht, es muss ja auch irgendwann wieder geladen werden etc.). Das Problem ist jetzt, das keiner Ernsthaft ~80 Properties einzeln in das ListItem der SharePoint Liste zu schreiben… geht natürlich auch.
Viel schöner ist aber, wenn wir einfach alle Properties der Klasse durchlaufen könnten und den Wert des entsprechenden Feldes zu setzen:

foreach (PropertyInfo mainprop in this.GetType().GetProperties())
{
	object fieldvalue = mainprop.GetValue(this, null).GetType().InvokeMember(
        	"Value", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);
        string fieldname = (string)mainprop.GetValue(this, null).GetType().InvokeMember(
                    "DisplayName", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);
        Guid fieldid = (Guid)mainprop.GetValue(this, null).GetType().InvokeMember(
                    "ID", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);

        if (item.Fields.GetField(fieldname).Type == SPFieldType.DateTime)
                    fieldvalue = SPUtility.CreateISO8601DateTimeFromSystemDateTime((DateTime)fieldvalue);

        item[fieldid] = fieldvalue;

        try
        {
		item.SystemUpdate();
	}
	catch (Exception ex)
        {
		LogMsg(ex.ToString());
                ErrorsOccured = true;
                mainprop.GetValue(this, null).GetType().InvokeMember("ErrorsDetected", BindingFlags.SetProperty, null,
                mainprop.GetValue(this, null),
                new object[] { true });
        }
}

Dank Reflection können wir mittels this.GetType().GetProperties() über alle Properties der aktuellen Klasse iterieren. Jetzt wollen wir aber nicht den Wert der Property haben, sondern den Wert der Value Eigenschaft der Property. Klar? Schön. :)
Da man eine Site Columns im SharePoint am sichersten über seine Guid ansprechen kann, wird die Guid sowie der aktuelle Wert der Value Eigenschaft ausgelesen und in das SPListItem geschrieben. Kling konfus, ist es auch. ;) Mittels InvokeMember und der Option BindingFlags.GetProperty kann man grob gesagt den Wert auslesen. Analog kann man mittems BindingFlags.SetProperty den Setter des Members aufrufen.
Klingt alles irgendwie merkwürdig, und wir lesen ja meistens lieber Code – daher hier einfach mal das was dabei rausgekommen ist:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;
using System.Collections;
using System.Reflection;
using Microsoft.SharePoint.Utilities;

namespace DataTypeTest
{
    #region class implementations
	// hier stehen alle Klassendefinitionen
	public class ProductReference
	{
	        public string StaticName { get { return "ProductReference"; } }
	        public string DisplayName { get { return Resources.Displayname_ProductReference; } }
	        public Guid ID { get { return new Guid("{6ebe0f28-af6a-40f7-9ad8-d9ff37d2b045}"); } }
	        public string TypeName { get { return "String"; } }
	        public Type Type { get { return typeof(String); } }
	        public String Value { get; set; }
		public bool ErrorsDetected { get; set; }
	}
	// etc.pp.
    #endregion

    public class NPPItem
    {
        #region properties
		// hier stehen die Properties
		public ProductReference ProductReference { get; set; }
		// etc. pp.
        #endregion

        public Action<string> Log;

        /// <summary>
        /// Initializes a new instance of the <see cref="Item"/> class.
        /// </summary>
        public Item(Action<string> LogFunction)
        {
            Log = LogFunction;
            InitFields();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Item"/> class.
        /// </summary>
        /// <param name="ListItemID">The list item ID.</param>
        /// <param name="WebUrl">The web URL.</param>
        /// <param name="ListId">The list id.</param>
        public Item(string ListItemID, string WebUrl, string ListId, Action<string> LogFunction, out bool ErrorsDetected)
        {
            if (string.IsNullOrEmpty(ListItemID) |
                string.IsNullOrEmpty(WebUrl) |
                string.IsNullOrEmpty(ListId))
                throw new ArgumentException("Empty params for Item(string ListItemID, string WebUrl, string ListId)!");
            Log = LogFunction;
            bool ErrorsOccured = false;
            int iItemId;
            if (!Int32.TryParse(ListItemID, out iItemId)) throw new ArgumentException("ListItemID is not a valid int!");

            InitFields();
            SPList liste = GetList(ListId, WebUrl);
            SPListItem litem = liste.GetItemById(iItemId);
            if (litem == null) { ErrorsDetected = true; return; }

            foreach (PropertyInfo mainprop in this.GetType().GetProperties())
            {
                Guid fieldid = (Guid)mainprop.GetValue(this, null).GetType().InvokeMember(
                    "ID", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);

                SPField spfield = litem.Fields[fieldid];
                object[] param = new object[1];
                try
                {
                    param[0] = Convert.ChangeType(spfield.GetFieldValueAsText(litem[fieldid]),
                        mainprop.GetValue(this, null).GetType().GetProperty("Value").PropertyType);
                    mainprop.GetValue(this, null).GetType().InvokeMember("Value", BindingFlags.SetProperty, null,
                    mainprop.GetValue(this, null),
                    param);
                }
                catch (Exception ex)
                {
                    LogMsg(ex.ToString());
                    ErrorsOccured = true;
                    mainprop.GetValue(this, null).GetType().InvokeMember("ErrorsDetected", BindingFlags.SetProperty, null,
                    mainprop.GetValue(this, null),
                    new object[] { true });
                }

            }
            ErrorsDetected = ErrorsOccured;
        }

        private void InitFields()
        {
            // instanzen erstellen... sicher ist sicher :)
            this.ProductReference = new ProductReference();
	    // etc.pp.
        }

        /// <summary>
        /// Saves the item.
        /// </summary>
        /// <param name="ListItemID">The list item ID. Submit -1 to create a new item</param>
        /// <param name="Data">The data.</param>
	/// <returns>ID of the new list item</returns>
        public bool SaveItem(int ListItemID, string WebUrl, string ListId, out int newListItemID)
        {
            bool ErrorsOccured = false;
            SPList liste = GetList(ListId, WebUrl);
            if (liste == null)
                throw new ArgumentException(string.Format("List {0} in site {1} does not exist or you have insufficient permissions",
                    ListId, WebUrl));

            SPListItem item = null;
            if (ListItemID == -1) item = liste.Items.Add();
            else item = liste.Items[ListItemID];
            if (item == null) throw new ArgumentException(string.Format("ListItem with ID '{0}' does not exist in list '{1}' at site '{2}' !",
                ListItemID, ListId, WebUrl));

            foreach (PropertyInfo mainprop in this.GetType().GetProperties())
            {
                object fieldvalue = mainprop.GetValue(this, null).GetType().InvokeMember(
                    "Value", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);
                string fieldname = (string)mainprop.GetValue(this, null).GetType().InvokeMember(
                    "DisplayName", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);
                Guid fieldid = (Guid)mainprop.GetValue(this, null).GetType().InvokeMember(
                    "ID", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);

                if (item.Fields.GetField(fieldname).Type == SPFieldType.DateTime)
                    fieldvalue = SPUtility.CreateISO8601DateTimeFromSystemDateTime((DateTime)fieldvalue);

                item[fieldid] = fieldvalue;

                try
                {
                    item.SystemUpdate();
                }
                catch (Exception ex)
                {
                    LogMsg(ex.ToString());
                    ErrorsOccured = true;
                    mainprop.GetValue(this, null).GetType().InvokeMember("ErrorsDetected", BindingFlags.SetProperty, null,
                    mainprop.GetValue(this, null),
                    new object[] { true });
                }
            }
            newListItemID = item.ID;
            return ErrorsOccured;
        }

        public List<string> GetPropertiesWithErrors()
        {
            List<string> result = new List<string>();
            foreach (PropertyInfo mainprop in this.GetType().GetProperties())
            {
                if (Convert.ToBoolean(mainprop.GetValue(this, null).GetType().InvokeMember(
                    "ErrorsDetected", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null)))
                    result.Add(mainprop.Name);
            }
            return result;
        }

        /// <summary>
        /// Gets a SPList.
        /// </summary>
        /// <param name="ListId">The list id.</param>
        /// <param name="SiteUrl">The site URL.</param>
        /// <returns>SPList if found, otherwise null</returns>
        private SPList GetList(string ListId, string SiteUrl)
        {
            if (ToGuid(ListId) == null) return null;
            SPList retval = null;
            using (SPSite site = new SPSite(SiteUrl))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    retval = web.Lists[ToGuid(ListId)];
                }
            }
            return retval;
        }

        /// <summary>
        /// Get a Guid object from a valid guid string
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns>valid GUID or null</returns>
        private Guid ToGuid(string input)
        {
            if (string.IsNullOrEmpty(input)) throw new ArgumentException("input is null");
            Guid retval = new Guid();
            try
            {
                retval = new Guid(input);
            }
            catch (Exception) { }
            return retval;
        }

        private void LogMsg(string Message)
        {
            if (this.Log != null)
                Log(Message);
        }

    }
}

Nice to have wäre natürlich noch, die ganze Show mit Interfaces zu versehen, so dass man nicht mehr hardcoded auf die Subpropertynamen losgehen muss, wie ich es bisher gemacht habe:

mainprop.GetValue(this, null).GetType().InvokeMember("Value", BindingFlags.GetProperty, null, mainprop.GetValue(this, null), null);

Ich brauch jetzt erstmal ein wenig Frischluft. :)

        private T GetControl(string id, ControlCollection ctls, bool ThrowExceptions) where T : Control
        {
            Control ctl = FindControl(id, ctls);
            if (ThrowExceptions && ctl == null)
                throw new Exception(string.Format("Cannot find control with id '{0}' !\n", id));
            if (ThrowExceptions && ctl.GetType() != typeof(T))
                throw new Exception(string.Format("Control with id '{0}' found , but it's type is not {1}!\n", id, typeof(T)));
            if (ctl == null) return null;
            T castedCtl = (T)ctl;
            return castedCtl;
        }

        private bool ControlExists(string id, ControlCollection ctls)
        {
            return (GetControl(id, ctls, false)) != null;
        }

        private Control FindControl(string id, ControlCollection ctls)
        {
            Control ctlsearched = null;
            foreach (Control ctl in ctls)
            {
                if (!string.IsNullOrEmpty(ctl.ID) && ctl.ID.Equals(id, StringComparison.InvariantCultureIgnoreCase))
                    ctlsearched = ctl;
                if (ctlsearched == null && ctl.HasControls())
                    ctlsearched = FindControl(id, ctl.Controls);

                if (ctlsearched != null) break;
            }
            return ctlsearched;
        }

Update
Manchmal sollte man doch mal Google oder ein paar der Blogs aus seinem RSSReader bemühen… dann wäre man auch auf den Post von Peter Bucher gestossen der das ganze Thema etwas ausführlicher schon im Januar behandelte. :)

class MyDataType
{
	public string Wert { get; set; }
	public static implicit operator string(MyDataType toConvert)
	{ return toConvert.Wert; }

	public static implicit operator MyOtherDataType(MyDataType toConvert)
	{
		int Converted;
		if (Int32.TryParse(toConvert.Wert, out Converted))
			return new MyOtherDataType() { Wert = Converted };
		else
			return null;
	}
}

Dazu definieren wir uns einen eigenen zweiten Datentypen:

class MyOtherDataType
{
	public int Wert { get; set; }
	public static implicit operator MyDataType(MyOtherDataType toConvert)
	{ return new MyDataType() { Wert = Convert.ToString(toConvert.Wert) }; }

	public static implicit operator string(MyOtherDataType toConvert)
	{
		if (toConvert != null)
			return Convert.ToString(toConvert.Wert);
		else
			return "toConvert is null";
	}
}

Ich habe jetzt allerdings die Konvertierungen zu SecureString rausgenommen, und implizite Konvertierungen zwischen diesen beiden Datentypen hinzugefügt. Prinzipiell muss nach dem Keyword “operator” lediglich der Zieldatentyp angegebene werden, und als Methodenparameter der Quelldatentyp. Das kann man so vereinfachen:

public static implicit/explicit operator Zieldatentyp (Quelldatentyp pInstance) { Konvertierungsimplementation }

Die Main Methode unserer Konsolenanwendung sieht demnach dann so aus:

static void Main(string[] args)
{
	MyDataType myTypeInstance = new MyDataType() { Wert = "hallo" };
	Log("myTypeInstance: " + myTypeInstance);

	//ist null, da "hallo" kein gültiger int ist
	MyOtherDataType myOtherTypeInstance = myTypeInstance;
	Log("myOtherTypeInstance nach ungültigem int in myTypeInstance: " + myOtherTypeInstance);

	myTypeInstance.Wert = "10";
	myOtherTypeInstance = myTypeInstance;
	Log("myOtherTypeInstance nach gültigem int in myTypeInstance: " + myOtherTypeInstance);
	Console.Read();
}

“Warum verwendet der jetzt nicht “string.Format” zum Logging?!” werden sich wohl einige Fragen. Die Antwort ist einfach: string.Format(“Text”, parameter) erwartet als parameter “objects”. Würden wir nun unsere Instanz “myOtherTypeInstance” übergeben, würde unsere Typumwandlung nach string nicht ausgeführt werden… :)
Damit sollte es jetzt eigentlich klar sein wie die eigene Konvertierungen direkt innerhalb eines Datentyps implementiert werden können.

class MyDataType
{
	public string Wert { get; set; }
}

Der Einfachheit halber nur eine simple Property. Normalerweise hat man ja sehr viele Unterschiedliche Properties in seinem Datentyp. Wir möchten jetzt daraus z.B. einen SecureString machen, oder auch einfach den Wert loggen. Man könnte jetzt natürlich einfach schreiben:

MyDataType myTypeInstance = new MyDataType() { Wert = "hallo" };

Log(myTypeInstance.Wert);

Wobei unsere Logfunktion einen string-Parameter entgegennimmt der dann – wo auch immer – protokolliert wird.

Diese Verwendung ist aber spätestens bei komplexeren Datentypen einfach nur unhandlich. Deshalb wollen wir einfach schreiben können:

Log(myTypeInstance);

oder um daraus einen SecureString zu machen:

SecureString mySecString = (SecureString)myTypeInstance;

Die meisten Implementierungen (die ich bisher gesehen habe) setzen auf eine extra ausgelagerte Funktion oder Extension methods. Die ausgelagerten Funktionen haben einen Nachteil: Sie konvertieren einfach mal alles was man reinwirft. Dieses Verhalten haben wir aber eigentlich nicht bezweckt, oder wir wollen das einfach nicht, da wir ja beim Zeitpunkt des Codens die Verwendungsmöglichkeiten einfach nicht alle im Überblick haben kann oder auch nicht testen kann.
Gehen wir also über Extension methods. OK – damit haben wir im Idealfall schonmal den Basistyp eingegrenzt. Nachteil allerdings hier: Extension methods funktionieren erst ab .Net 3.5… Also stehen wir wieder am Anfang.

Wie gehen wir also nun an die Sache ran?
Die Lösung ist liegt auf der Hand und ist eigentlich so simpel, das es mich immer wieder verwundert das es so selten eingesetzt wird:
Innerhalb unseres Datentyps definieren wir zwei neue statische Funktionen zur Typumwandlung hinzu:

public static implicit operator string(MyDataType toConvert) { }

public static explicit operator SecureString(MyDataType toConvert) { }

Diese beiden Funktionen führen nun unsere gewünschten impliziten wie expliziten Konvertierungen aus.
Wir füllen diese beiden Methoden also wie folgt auf:

public static implicit operator string(MyDataType toConvert)
{
	return toConvert.Wert;
}
public static explicit operator SecureString(MyDataType toConvert)
{
	SecureString mySecureString = new SecureString();
        foreach (char item in toConvert.Wert)
	{
		mySecureString.AppendChar(item);
	}
	return mySecureString;
}

Das heißt, dadurch gewinnen wir saubereren Code und klarere Strukturen, da die Umwandlungen direkt innerhalb der Typen definiert werden können. Sie sind also genau da, wo sie auch hingehören.
Das komplette Testprogamm hier:

class MyDataType
{
	public string Wert { get; set; }
	public static implicit operator string(MyDataType toConvert)
	{
		return toConvert.Wert;
	}
	public static explicit operator SecureString(MyDataType toConvert)
	{
		SecureString mySecureString = new SecureString();
		foreach (char item in toConvert.Wert)
		{
			mySecureString.AppendChar(item);
		}
		return mySecureString;
	}
}

class Program
{
	static void Main(string[] args)
	{
		MyDataType myTypeInstance = new MyDataType() { Wert = "hallo" };
		Log(myTypeInstance);
		SecureString mySecString = (SecureString)myTypeInstance;
		Log(mySecString.ToString());
		Console.Read();
	}
	static void Log(string message)
	{
		Console.WriteLine(message);
	}
}

Def: Wird in einem Iterator-Block verwendet, um für das Enumerationsobjekt einen Wert zu liefern oder um das Ende der Iteration zu signalisieren.
Der Ausdruck wird ausgewertet und als ein Wert an das Enumerationsobjekt zurückgegeben. Der expression muss implizit in den yield-Typ des Iterators konvertierbar sein.
Die yield-Anweisung kann nur innerhalb eines iterator-Blocks stehen, der als Rumpf einer Methode, eines Operators oder eines Accessors verwendet wird. Der Rumpf solcher Methoden, Operatoren oder Accessoren unterliegt folgenden Einschränkungen:

- Unsichere Blöcke werden nicht zugelassen.
- Parameter für die Methode, den Operator oder den Accessor dürfen nicht ref oder out sein.

Eine yield-Anweisung darf nicht in einer anonymen Methode stehen. Weitere Informationen finden Sie unter Anonyme Methoden (C#-Programmierhandbuch).
Bei Verwendung mit expression darf eine yield return-Anweisung nicht in einem catch-Block oder einem try-Block stehen, der mehr als eine catch-Klausel enthält.

Wie sieht das jetzt in der Praxis aus?
Das Beispiel in der MSDN ist jetzt nicht besonders praxistauglich, daher hier mal eine andere Verwendungsweise:

class Program
    {
        static void Main(string[] args)
        {
            string searchedCRMId = "de7ea510-8e55-de11-a210-0017084f5232";
            Console.WriteLine("Starting to search for user with CRM_ID '{0}'...", searchedCRMId);
            foreach (UserProfile item in GetProfiles("http://your_ssp_host/"))
            {
                string currentID = Convert.ToString(item["CRMUserID"].Value);
                if (string.IsNullOrEmpty(currentID))
                    continue;

if (currentID.Equals(searchedCRMId, StringComparison.CurrentCultureIgnoreCase))
                {
                    Console.WriteLine("Found searched user!\nAccountname: {0}", item[PropertyConstants.AccountName].Value);
                    break;
                }
            }
            Console.WriteLine("Done");
            Console.ReadLine();
        }

static IEnumerable<UserProfile> GetProfiles(string SharedServiceProviderUrl)
        {
            SPWebApplication webapp = SPWebApplication.Lookup(new Uri(SharedServiceProviderUrl));
            UserProfileManager upm = new UserProfileManager(ServerContext.GetContext(webapp));
            foreach (UserProfile profile in upm)
            {
                yield return profile;
            }
        }
    }

Diese ConsoleApplication iteriert über alle vorhandenen UserProfile und vergleicht eine CustomProperty mit einem Suchwert. In der GetProfiles() Methode wird allerdings mittels “yield return profile” das aktuelle Profil aus der Auflistung zurückgegeben und die übergeordnete foreach-Schleife weiter bearbeitet. Das spart zum einen Performance und zum anderen Speicher.
Zu beachten ist dabei allerdings, das bei folgender Verwendung immer das erste Item “verschwindet”:

IEnumerable<UserProfile> profileList = GetProfiles("http://your_ssp_host/");
foreach (UserProfile item in profileList)
{
 string currentID = Convert.ToString(item["CRMUserID"].Value);
        if (string.IsNullOrEmpty(currentID))
         continue;

if (currentID.Equals(searchedCRMId, StringComparison.CurrentCultureIgnoreCase))
        {
         Console.WriteLine("Found searched user!\nAccountname: {0}", item[PropertyConstants.AccountName].Value);
                break;
        }
}

Die Ursache ist recht einfach:

Was man letztendlich verwendet ist natürlich immer von der Anforderung abhängig. :)

1. Da ich mit und für SharePoint entwickle nutze ich den WSPBuilder. Dieses Tool nimmt einem viel manuelle Arbeit bei der Entwicklung ab (Anhängen an die IIS Prozesse zum Debuggen, viele Itemtemplates, leichte Konfigurierbarkeit und große Erweiterbarkeit)
2. Sandcastle in Verbindung mit dem Sandcastle Help File Builder. Diese beiden Tools ersparen sehr viel Arbeit bei der Generierung von ansprechenden Dokumentationen. Man muss nicht mehr selbst die HTML Files erstellen und in ein CHM packen, einfach in die Post-Build Action der Release Version diese beiden Tools integrieren und man bekommt zu jedem neuen Release eine komplette Dokumentation für den Kunden. Einfach, praktisch, gut.
3. Die Team Foundation Power Tools ! Unverzichtbar bei der Entwicklung, vor allem aber beim Projektstart und der Projektvorbereitung. Wer den Team Foundation Server nutzt und diese Tools nicht einsetzt ist selber Schuld. :)

Ein super Beispiel wie man das unter .NET verwendet findet man im Channel9. Hier gibt es eine komplette Solution mit verschiedenen Szenarien (TxF Only, TxF and SQL, TxF and WCF). Und auch die MSDN liefert einige Informationen zum Thema. Das hört sich ja alles schonmal ganz praktisch an.

Das KO-Kriterium für diese Technik ist allerdings folgendes:

Unsupported Scenarios
TxF does not support the following transaction scenarios:
- Transactions on network volumes, for example on file shares. TxF is not supported by the CIFS/SMB protocols.
- Transacted operations against files cached by client-side caching.

Nun, bei diesen Einschränkungen fällt mir kein praktisches Einsatzszenario für diese Technik ein… Soviel dann also zum Thema “Totes Pferd”.

• RegEx_HasMatches soll uns sagen ob überhaupt Matches auftreten
• RegEx_MatchCount soll uns sagen wie viele Matches auftreten
• RegEx_GetMatches soll uns die Matches aufsgeben

Für die Copy+Paster unter euch ;) :

    <SqlFunction()> _
    Public Shared Function RegEx_HasMatches(ByVal inputstring As SqlString, ByVal regexstring As SqlString) As SqlBoolean
        If Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase).Count > 0 Then
            Return True
        Else
            Return False
        End If
    End Function

    <SqlFunction()> _
    Public Shared Function RegEx_MatchCount(ByVal inputstring As SqlString, ByVal regexstring As SqlString) As SqlInt64
        Return Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase).Count
    End Function

    <SqlFunction()> _
    Public Shared Sub RegEx_GetMatches(ByVal inputstring As SqlString, ByVal regexstring As SqlString)
        Dim mc As MatchCollection = Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase)
        Dim result As New SqlDataRecord(New SqlMetaData("Match", SqlDbType.NVarChar, 4000))
        Dim pipe As SqlPipe = SqlContext.Pipe
        pipe.SendResultsStart(result)
        For Each item As Match In mc
            result.SetString(0, item.Value)
            pipe.SendResultsRow(result)
        Next
        pipe.SendResultsEnd()
    End Sub

Nach dem Bereitstellen können wir das ganze auch schon testen:

declare @inputstring nvarchar(4000)
set @inputstring= 'My favorite web sites include:
	</P><A HREF="http://www.xentrope.de">Xylon''s Blog</A></P>
	<A HREF="http://dotnet-forum.de">.NET Forum</A></P>
	<A HREF="http://blogs.msdn.com/bclteam">.NET Base Class Library blog</A></P>'

declare @regexstring nvarchar(4000)
set @regexstring = 'href\s*=\s*(?:"(?<1>[^"]*)"|(?<1>\S+))'

select dbo.RegEx_HasMatches(@inputstring,@regexstring) 'HasMatches'
	,dbo.RegEx_MatchCount(@inputstring,@regexstring) 'Nr of Matches'
exec dbo.RegEx_GetMatches @inputstring,@regexstring

Und als Ergebnisse bekommen wir:

HasMatches	Nr of Matches
1			3

Match
HREF="http://www.xentrope.de"
HREF="http://dotnet-forum.de"
HREF="http://blogs.msdn.com/bclteam"

Coole Sache! :)

• Man erstellt im Visual Studio ein neues Datenbankprojekt.
• In den Projekteinstellungen sollte die Assembly signiert werden (Einstellungen – Signing – Sign the assembly)
• Unter dem Karteireiter “Database” kann vorerst das Permissionlevel auf Safe bleiben, da wir ja keine externen Resources ansprechen wollen.
  Safe = Zugriff auf Daten des eigenen SQL Servers über den In-process Managed Provider
  External = Zugriff auf externe Resourcen ist erlaubt
  Unsafe = Es kann unmanaged Code ausgeführt werden
  Erhält man eine Fehlermeldung beim Bereitstellen der Assembly, kann es daran liegen das der Datenbank nicht vertraut wird. Dann sollte man die Trustworthy Eigenschaft setzen:

  Alter Database [DB] Set Trustworthy on
  

• Man fügt dem Projekt eine neue Klasse hinzu, ich habe sie einfach “Stringfunctions” genannt.
• Dieser Klasse fügen wir eine Prozedur hinzu:

      <SqlProcedure()> _
      Public Shared Sub Split(ByVal Input As SqlString, ByVal Delimiter As SqlString)
          Dim pipe As SqlPipe = SqlContext.Pipe
          Dim splittet() As String = Input.Value.Split(Delimiter.Value.ToCharArray)
          Dim reslist As New List(Of SqlMetaData)
          For i As Integer = 0 To splittet.Length - 1
              reslist.Add(New SqlMetaData("Col" + i.ToString(), SqlDbType.NVarChar, 4000))
          Next
          Dim result As New SqlDataRecord(reslist.ToArray())
          For i As Integer = 0 To splittet.Length - 1
              result.SetString(i, splittet(i))
          Next
          pipe.Send(result)
      End Sub
  

  Das Attribut SqlProcedure() sorgt dafür, das beim Bereitstellen automatisch eine neue Stored Procedure angelegt wird. Als Parameter der Prozedur übergeben wir zwei SQLStrings: Input und Delimiter. Wofür diese stehen sagen die Namen ja schon… ;) Um die Anzahl der notwendigen Spalten in unserer Ergnistabelle zu ermitteln legen wir uns ersteinmal eine neue Liste mit Spaltendefinitionen an. Danach wird unsere Ergebnistabelle erstellt:

  Dim result As New SqlDataRecord(reslist.ToArray())
  

  Jetzt können wir endlich alle Elemente aus dem Array in die Ergebnistabelle schreiben und zurückgeben:

  For i As Integer = 0 To splittet.Length - 1
  	result.SetString(i, splittet(i))
  Next
  pipe.Send(result)
  

  Die Verwendung der Funktion ist denkbar einfach:

  exec Split 'feld1;feld2;feld3;feld4;feld5;feld6;feld7',';'
  

  Und liefert uns eine Tabelle zurück:

   Col0	Col1	Col2	Col3	Col4	Col5	Col6
   feld1	feld2	feld3	feld4	feld5	feld6	feld7