Xylon's Blog » ASP.Net 2

System.Reflection.Konfusion

Rene Muster — Fri, 30 Oct 2009 19:06:06 +0000

Entwickler sind faul – ich zumindest. Ich will möglichst wenig Code schreiben, aber strukturiert. Nun ergab es sich, das man einen Datentyp mit circa 80 eigenen Properties – welche ebenfalls wieder eigene Klassen sind – erstellen sollte. Dieser Job ist ja nun leicht erledigt. Man hacke fix ein Consolenprogramm welches aus einer XMl-Datei (in der die Klassen und Datentypen enthalten sind) einen Datentyp bastelt.
Das sieht dann letztendlich so aus (exemplarisch mal eine Klasse und der Datentyp):

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 Log;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        public Item(Action LogFunction)
        {
            Log = LogFunction;
            InitFields();
        }

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The list item ID.
        /// The web URL.
        /// The list id.
        public Item(string ListItemID, string WebUrl, string ListId, Action 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.
        }

        /// 
        /// Saves the item.
        /// 
        /// The list item ID. Submit -1 to create a new item
        /// The data.
	/// ID of the new list item
        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 GetPropertiesWithErrors()
        {
            List result = new List();
            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;
        }

        /// 
        /// Gets a SPList.
        /// 
        /// The list id.
        /// The site URL.
        /// SPList if found, otherwise null
        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;
        }

        /// 
        /// Get a Guid object from a valid guid string
        /// 
        /// The input.
        /// valid GUID or null
        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. :)

Standard Pitfall mit Page.FindControl [Update]

Rene Muster — Mon, 26 Oct 2009 13:43:55 +0000

Reminder an micht selbst:
Page.FindControl arbeitet nicht rekursiv. :>
Alternativfunktionen für rekursives Suchen und Holen von Controls:

        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. :)

Nachtrag: TypeConversions reloaded

Rene Muster — Wed, 01 Jul 2009 11:58:11 +0000

Ich hatte ja hier schon etwas zu eigenen impliziten und expliziten Konvertierungen geschrieben. Dazu noch ein Nachtrag zur Konvertierungen zwischen zwei eigenen Datentypen. Wir haben wieder unseren Datentypen MyDataType:

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.

Split Funktion mittels CLR

Rene Muster — Wed, 03 Sep 2008 09:00:21 +0000

Eine beliebte Stringfunktion fehler leider nach wie vor im SLQ Server: Split. Das hat sich auch mit dem neuen SQL Server 2008 immer noch nicht geändert. Ich hatte ja schon mal eine Splitfunktion gepostet, möchte dies aber jetzt als CLR Funktion implementieren. Lange Reder kurzer Sinn:

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:

     _
    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

Abgeschnittene Strings

Rene Muster — Mon, 25 Aug 2008 11:26:38 +0000

Ein anderes interessantes Phänomen lief mir gerade über den Weg: Liest man aus einem SQL Server eine richtig lange Zeichenkette (z.B. mehr als 2000 Zeichen, z.B. mit einer ‘FOR XML …’ Transformation im Select) wird einem das Ergebnis willkürlich bei um die 1000 Zeichen abgeschitten.
Eine generelle Workaroundfunktion ist schnell gebastelt:

Private Shared Function GetLongStringData(ByVal statement As String) As String
	Dim sql As New System.Data.SqlClient.SqlCommand()
	Dim con As New System.Data.SqlClient.SqlConnection()
	con.ConnectionString = "connectionstring"
	sql.CommandText = statement
	sql.Connection = con
	con.Open()
	Dim r As System.Data.SqlClient.SqlDataReader = sql.ExecuteReader()
	Dim strbuilder As New StringBuilder()
	While r.Read()
		strbuilder.Append(r(0))
	End While
	con.Close()
	Return strbuilder.ToString()
End Function

Stellt sich allerdings nach wie vor die Frage warum die Daten abgeschnitten werden. Im SQL Server Management Studio wird alles korrekt angezeigt. Ich vermute das Problem liegt irgendwo bei der Übergabe vom SQL Server in den .Net String. Wenn jemand eine Idee hat, möge er sich bei mir melden. :)

ASP.NET 2 in 30 minutes: Feeds made simple

Rene Muster — Sun, 06 Apr 2008 19:14:41 +0000

Newsfeeds können sehr praktisch sein. Schon mal an eine Interaktion von Feed <-> System Management Server oder Feed <-> Domain gedacht?
Ein praktisches Beispiel:
In einem Unternehmen werden regelmäßig Systemhotfixe, Systemupdates, Application Updates etc. verteilt. Dabei sollen die User aber vorher informiert werden damit sie wissen, das ein Update zur Installation ansteht oder das die Performance kurzfristig beeinträchtigt werden kann.
In der Regel gehen dann ellenlange Mails mit (für den User) unverständlichen Informationen durch das Unternehmen.
Man könnte aber auch einen (oder mehrere) zentrale(n) Newsfeed(s) anbieten. Einen für Hotfixe, noch einen für Office-Patches oder auch einen für Updates einer spezifischen Software (Visual Studio meinetwegen).
Großes Gerede, aber was brauchen wir?
Wie benötigen ein wenig ASP.Net 2 Webspace. Wenn vorhanden noch eine SQL-Datenbank, es reicht aber auch wenn man eine Access-Datenbank nutzt.
Dort legt man 2 Tabellen an:

CREATE TABLE Channels (
[id] [int] IDENTITY(1,1) NOT NULL,
[title] [nvarchar](255) NULL,
[description] [ntext] NULL,
[managingeditor] [nvarchar](50) NULL,
[webmaster] [nvarchar](50) NULL);

CREATE TABLE Items(
[id] [int] IDENTITY(1,1) NOT NULL,
[title] [nvarchar](255) NULL,
[description] [ntext] NULL,
[pubdate] [datetime] NULL,
[author] [nvarchar](50) NULL,
[channel] [int] NULL,
[published] [bit] NULL DEFAULT ((0)),
[targetou] [ntext] NULL,
[smscollection] [nvarchar](50) NULL,
[clientlist] [ntext] NULL);

Die Tabellennamen sind selbsterklärend: Channels für die verfügbaren Feeds und Items für alle Nachrichten. Bei der Tabelle Items habe ich 3 Spalten um die Nachrichten genauer zu Verteilen:
In “targetou” kann ein spezifischer LDAP-String eingetragen werden, sodass später nur Clients die Nachricht bekommen die auch Mitglied der OU sind. Gleiches gilt für “smscollection”. Eine eingetragene Collection aus SMS stellt sicher, das nur Clients die in der Collection sind die Nachricht erhalten. Und die Spalte “clientlist” ist für spezifische Rechnerlisten. Dort sollen Semikolonseparierte FQDN-Namen von Rechnern eingetragen werden die die Nachricht erhalten sollen (z.B. zur Definition von Testfeldern).

Weiterhin benötigen wir eine Webseite Default.aspx die uns alle verfügbaren Feeds auflistet:





<%#eval("title") %>

<%#Eval("description")%>

<%#String.Format("", Eval("id"))%>
<%#String.Format("", Eval("id"))%>

Ich habe eine Accessdatenbank in den App_Data Ordner gepackt, man kann aber auch andere Datenbanksysteme einsetzen. Wie man sieht, habe ich 2 Formate implementiert: RSS und ATOM.
Der Grund ist simpel: Im RSS ist nach Definition kein HTML-Code erlaubt. Im ATOM-Format ist dies erlaubt.
Fehlt uns noch die Datei “service.aspx” die letztendlich für die Auslieferung der Feeds zuständig ist.
Im Page_Load Ereignis müssen wir nur prüfen ob eine FeedID übergeben wurde.

        If Request.QueryString("feed") Is Nothing Or _
Request.QueryString("feed").Trim = "" Then Exit Sub
Response.Clear()
Response.ContentType = "text/xml"
If Request.QueryString("Format") IsNot Nothing Then
Select Case Request.QueryString("Format").ToUpper
Case "ATOM" : Response.Write(GenerateAtomFeed)
Case Else : Response.Write(GenerateRSSFeed)
End Select
Else
Response.Write(GenerateRSSFeed)
End If
Response.End()

Weiterhin wird unterschieden ob ein spezielles Format gewünscht ist, per Defautl verwenden wir RSS.
Die 3 wichtigsten Funktionen zum Generieren der Feeds:

    Private Function GetAllItems(ByVal channelid As String) As List(Of message)
Dim SqlAllItems As New AccessDataSource
SqlAllItems.DataFile = AppSettings("Database")
SqlAllItems.SelectCommand = AppSettings("AllItems_SelectCommand")
Dim retval As New List(Of message)
SqlAllItems.SelectParameters.Clear()
SqlAllItems.SelectParameters.Add("channel", channelid)
'alle nachrichten des channels
Dim itemlist As Data.DataView = SqlAllItems.Select(DataSourceSelectArguments.Empty)
For j As Integer = 0 To itemlist.Count - 1
Dim msg As New message
With msg
.title = itemlist(j)("title").ToString
.description = itemlist(j)("description").ToString
.clientlist = itemlist(j)("clientlist").ToString
.id = itemlist(j)("id").ToString
.pubdate = itemlist(j)("pubdate").ToString
.smscollection = itemlist(j)("smscollection").ToString
.targetou = itemlist(j)("targetou").ToString
.author = itemlist(j)("author").ToString
End With
retval.Add(msg)
Next
Return retval
End Function

Private Function GenerateAtomFeed() As String
Dim responsetext As New StringBuilder
Dim reqclient As String = Net.Dns.GetHostEntry(Request.UserHostName).HostName
responsetext.Append(" ")
'alle channels durchgehen
Dim chinfo As channel = GetChannelInfo(Request.QueryString("feed"))
responsetext.AppendFormat("", chinfo.title)
responsetext.AppendFormat("{0}", chinfo.description)
responsetext.AppendFormat("urn:uuid:{0}", chinfo.id)
responsetext.AppendFormat("{0}", chinfo.webmaster)
responsetext.AppendFormat("{0}", chinfo.managingeditor)
For Each tmp As message In GetAllItems(chinfo.id)
Dim additem As Boolean = False
If tmp.clientlist.Trim.Length > 1 Then
If tmp.clientlist.ToUpper.Contains(reqclient.ToUpper) Then
additem = True
End If
ElseIf tmp.smscollection.Trim.Length > 1 Then
If IsClientInCollection(reqclient, tmp.smscollection) Then additem = True
ElseIf tmp.targetou.Trim.Length > 1 Then
If IsClientInOU(reqclient, tmp.targetou) Then additem = True
Else
additem = True
End If
If additem Then
With responsetext
.Append("")
.AppendFormat("", tmp.title)
.Append("")
.AppendFormat("
{0}

", tmp.description)
.Append("")
.AppendFormat("{0}", tmp.pubdate)
.AppendFormat("{0}", tmp.author)
.AppendFormat("urn:uuid:{0}", tmp.id)
.Append("")
End With
End If
Next
responsetext.Append("")
Return responsetext.ToString
End Function

Private Function GenerateRSSFeed() As String
Dim responsetext As New StringBuilder
Dim reqclient As String = Net.Dns.GetHostEntry(Request.UserHostName).HostName
responsetext.Append("")
'alle channels durchgehen
Dim chinfo As channel = GetChannelInfo(Request.QueryString("feed"))
responsetext.Append("")
responsetext.AppendFormat("", chinfo.title)
responsetext.AppendFormat("{0}", chinfo.description)
responsetext.AppendFormat("{0}", chinfo.webmaster)
responsetext.AppendFormat("{0}", chinfo.managingeditor)
For Each tmp As message In GetAllItems(chinfo.id)
Dim additem As Boolean = False
If tmp.clientlist.Trim.Length > 1 Then
If tmp.clientlist.ToUpper.Contains(reqclient.ToUpper) Then
additem = True
End If
ElseIf tmp.smscollection.Trim.Length > 1 Then
If IsClientInCollection(reqclient, tmp.smscollection) Then additem = True
ElseIf tmp.targetou.Trim.Length > 1 Then
If IsClientInOU(reqclient, tmp.targetou) Then additem = True
Else
additem = True
End If
If additem Then
With responsetext
.Append("")
.AppendFormat("", tmp.title)
.AppendFormat("", tmp.description)
.AppendFormat("
{0}", tmp.pubdate)
.AppendFormat("{0}", tmp.author)
.Append("")
End With
End If
Next
responsetext.Append("")
responsetext.Append("")
Return responsetext.ToString
End Function

Ich hatte geschrieben, das wir prüfen wollen ob ein Rechner in einer bestimmten OU oder Collection enthalten ist:

    Private Function IsClientInCollection(ByVal client As String, ByVal collection As String) As Boolean
Dim SqlSMSCollection As New AccessDataSource
SqlSMSCollection.DataFile = AppSettings("Database")
SqlSMSCollection.SelectCommand = AppSettings("SMSCollection_SelectCommand")
SqlSMSCollection.SelectParameters.Clear()
SqlSMSCollection.SelectParameters.Add("smscoll", collection)
SqlSMSCollection.SelectParameters.Add("client", client.Split(".")(0))
Dim dv As Data.DataView = SqlSMSCollection.Select(DataSourceSelectArguments.Empty)
If dv IsNot Nothing Then
If dv.Count > 0 Then
Dim clientsmscoll As String = dv(0)("Collection")
If clientsmscoll.ToUpper = collection.ToUpper Then Return True
End If
End If
Return False
End Function

Private Function IsClientInOU(ByVal client As String, ByVal ou As String) As Boolean
Dim SqlComputerOU As New AccessDataSource
SqlComputerOU.DataFile = AppSettings("Database")
SqlComputerOU.SelectCommand = AppSettings("ComputerOU_SelectCommand")
SqlComputerOU.SelectParameters.Clear()
SqlComputerOU.SelectParameters.Add("client", client.Split(".")(0))
Dim dv As Data.DataView = SqlComputerOU.Select(DataSourceSelectArguments.Empty)
If dv IsNot Nothing Then
If dv.Count > 0 Then
Dim clientou As String = dv(0)("distinguishedname")
clientou = clientou.Substring(clientou.IndexOf(","))
If String.Compare(clientou, ou, True) Then Return True
End If
End If
Return False
End Function

Jedem, der jetzt noch da ist dürfte aufgefallen sein, das die Application Settings aus der web.config fehlen:

Den Key “ComputerOU_SelectCommand” muss man gegebenfalls anpassen wenn man ein Mirror des Active Direcotys in einer Datenbank zur Verfügung hat. Wenn nicht, muss die Funktion “IsClientInOU” angepasst werden sodass direkt per LDAP geprüft wird.

Damit ist die ganze Show getan. Man sollte jetzt noch ein Admin-Interface zusammenschrauben.

Beispielsourcecode