1. Entfernung der ungültigen Accounts aus der Metabase
2. Hinzufügen von IIS_WPG mit den nötigen Rechten.

Warum dieser Beitrag

Wie sieht vernünftige Ausnahmebehandlung aus

try

{

...

}
catch(
... )

{

...

}
catch(
Exception ex )

{

log.Error("Unbehandelte
Ausnahme", ex );
throw;

}

Im konkreten Beispiel wurde log4net verwendet. Wichtig für das Thema ist jedoch, das der rethrow-Mechanismus von .NET verwendet wird.

Wann sollen eigene Ausnahmen erzeugt werden

Fazit

Um NAnt mitzuteilen, welche Version des .NET Frameworks beim Kompilieren verwendet werden soll, muss einfach nur das Property "nant.settings.currentframework" entsprechend gesetzt werden. Sollen die Sourcen mit Framework 1.1 übersetzt werden, so ist im Buildscript folgendes zu notieren:

<property name="nant.settings.currentframework" value="net-1.1" />

Das Framework kann allerdings auch über die Kommandozeile angegeben werden mittels:

nant.exe -t:net-1.1

Wenn eine ConfigSection mittels

System.Configuration.ConfigurationManager.GetSection("section")

eingelesen wird, ruft .NET den für die Section angegebenen Handler auf. Der Handler, welcher vom Typ IConfigurationSectionHandler ist, gibt lt. Schnittstelle ein Objekt vom Typ object zurück. Soweit so gut.

Wer nun denkt, das beim nochmaligen Aufruf von ConfigurationManager.GetSection(...) der Handler wiederholt aufgerufen wird, liegt falsch. Der ConfigurationManager gibt das selbe Objekt wie beim ersten Aufruf zurück. Man sollte vermeiden, irgendwelche Verlaufsdaten in diesem Konfigurationsobjekt abzulegen. Es kann sonst passieren das Daten ungewollt, über Sessions hinweg, gemeinsam genutzt werden.

Merksatz 1.0:
Die Section dient der Konfiguration von Geschäftsklassen und ist nicht selbst die Geschäftsklasse.

//
<summary>
///
Gets the object.
///
</summary>
///
<param name="node">The node.</param>
///
<returns></returns>
privatestatic T
GetObject<T>(XmlNode node)

{

T result =default(T);


    //restore
object from node

XmlSerializer ser =new XmlSerializer(typeof(T));

result = (T)ser.Deserialize(new StringReader(node.OuterXml));

return result;

}

///
<summary>
///
Sets the object.
///
</summary>
///
<param name="node">The node.</param>
///
<param name="value">The value.</param>
privatestaticvoid SetObject<T>(XmlNode
node, T value)

{
if(value
== null)

{
return;

}

using(MemoryStream
stream =new MemoryStream())

{
//serialize
object

XmlSerializer ser =new XmlSerializer(typeof(T));

ser.Serialize(stream, value);

//reset
read position

stream.Position = 0;


XmlElement newNode =null;

using(XmlReader
reader = XmlReader.Create(stream))

{
//move
to the content node.

reader.MoveToContent();
//create
new element in node context

newNode = node.OwnerDocument.CreateElement(reader.Name);
//set
content 

newNode.InnerXml = reader.ReadInnerXml();

}

//append
the new node

node.AppendChild(newNode);

}

}

publicstatic T
GetValue<T>(XmlNode node, T @default)

{

    ...

    if(!IsConvertible(typeof(T)))

    {

        //get
complex object

        result = GetObject<T>(node);

        result = result
!=null ?
result : @default;

    }

    else

    {

        ...

    }

    ...

}

publicstaticvoid SetValue<T>(XmlNode
node, T value)

{

    ...

    if(!IsConvertible(typeof(T)))

    {

        SetObject<T>(node, value);

        return;

    }

    ...

}

• Das Löschen von Objektknoten ist in dieser Variante nicht möglich
• Das Setzen eines komplexen Objektes führt immer zu einem anfügen. Durch die nicht vorhandene Objektidentität wird bei mehrfachen Aufrufen das Objekt auch mehrfach hinzugefügt.
• Das unterschiedliche Verhalten von Lesen und Schreiben kann zu Irritationen führen.
• Die XML-Serialisierung kann unter Umständen nicht erfolgreich sein, was dann einige Anforderungen an die Klassen stellt, um dies dennoch zu ermöglichen.
  

Nachdem mich am Donnerstag ein Virus dahin gerafft hat und ich das Bett hüten durfte, soll es heute wieder was neues geben.

Häufig hat man es mit XML-Daten zu tun, welche ausgelesen und bearbeitet werden sollen. Die enthaltenen Daten sind oft von einem bestimmten Typ. Die nachfolgende Hilfsklasse stellt Schnittstellen zur Verfügung, um die notwendigen Typumwandlungen zu kapseln. Diese Variante funktioniert nur mit Typen welche IConvertible implementieren. Eine Erweiterung, welche diese Einschränkung nicht besitzt, gibt es morgen. :)

          
            using System.Xml;
using System;

namespace de.wwaitz.Utils.XmlHelper

{
publicclass NodeHelper

{
///
<summary>
///
Gets a value indicating whether T is convertible.
///
</summary>
///
<value>
///
    <c>true</c> if T is convertible; otherwise, <c>false</c>.
///
</value>
publicstaticbool IsConvertible(Type
resultType)

{
returntypeof(IConvertible).IsAssignableFrom(resultType);

}

///
<summary>
///
Gets the value.
///
</summary>
///
<param name="node">The node.</param>
///
<param name="@default">The @default.</param>
///
<returns></returns>
publicstatic T
GetValue<T>(XmlNode node, T @default)

{

T result = @default;

if(node
== null)
{
//invalid
node
return result;

}

if(!IsConvertible(typeof(T)))
{
//cast
is not possible
return result;

}

//get
value
string toGet = node.InnerText;
//convert
to T

result = (T)Convert.ChangeType(toGet, typeof(T));

return result;

}

///
<summary>
///
Sets the value.
///
</summary>
///
<param name="node">The node.</param>
///
<param name="value">The value.</param>
publicstaticvoid SetValue<T>(XmlNode
node, T value)

{
if(node
== null)
{
//invalid
node
return;

}

if(!IsConvertible(typeof(T)))
{
//cast
is not possible
return;

}

string toSet = Convert.ToString(value);

node.InnerText = toSet;

}

}

}

        

Die Verwendung könnte dann wie folgt aussehen:

          
            internal
            class Program

{
privatestaticvoid Main(string[]
args)

{
string xml ="<root><my-bool>true</my-bool></root>";

XmlDocument doc =new XmlDocument();

doc.LoadXml(xml);

bool myBool = NodeHelper.GetValue<bool>(doc.DocumentElement["my-bool"], false);

NodeHelper.SetValue<bool>(doc.DocumentElement["my-bool"],
!myBool);

}

}
        

using System;
using System.Collections.Generic;
using System.Reflection;

namespace System.Collections.Generic

{
///
<summary>
///
Ein generischer Algorithmus zum sortieren von Listen.
///
</summary>
publicclass GenericSort<T>
: IComparer<T>

{
private MethodInfo
_method;

///
<summary>
///
Erzeugt eine Instanz des Typs
///
[invariant] Der übergebene Member kann eine Methode oder ein Property sein.
///
Handelt es sich um eine Methode, darf sie keinen Parameter 
///
besitzen. der Rückgabetyp der Eigenschaft/Methode muß vom Typ
///
IComparable sein.
///
</summary>
///
<param name="member"></param>
public GenericSort(string member)

{

MemberInfo[] infos =typeof (T).GetMember(member);

foreach (MemberInfo
info in infos)

{
if (info.MemberType
== MemberTypes.Property)

{
if (Initialize((PropertyInfo)
info))
break;

}
elseif (info.MemberType
== MemberTypes.Method)

{
if (Initialize((MethodInfo)
info))
break;

}

}

if(_method
== null)
thrownew InvalidOperationException("Member
does not match the class invariant");

}

///
<summary>
///
Initializes the specified info.
///
</summary>
///
<param name="info">The info.</param>
///
<returns></returns>
privatebool Initialize(PropertyInfo
info)

{
return Initialize(info.GetGetMethod());

}

///
<summary>
///
Initializes the specified info.
///
</summary>
///
<param name="info">The info.</param>
///
<returns></returns>
privatebool Initialize(MethodInfo
info)

{
if(info.GetParameters().Length
> 0)
returnfalse;

if(!typeof(IComparable).IsAssignableFrom(info.ReturnType))
returnfalse;


_method = info;
returntrue;

}

///
<summary>
///
Compares two objects and returns a value indicating whether one is less than, 


/// equal to, or greater than the other.
///
</summary>
///
<param name="x">The first object to compare.</param>
///
<param name="y">The second object to compare.</param>
///
<returns>
///
Value Condition Less than zerox is less than y.Zerox equals y.Greater 


/// than zerox is greater than y.
///
</returns>
publicint Compare(T
x, T y)

{
return ((IComparable)
_method.Invoke(x, null)).CompareTo(_method.Invoke(y, null));

}

}

}

publicclass Program

{

    publicstaticvoid Main(string[]
args)

    {

        List<SomeType> list =new List<SomeType>();


        //Code


        list.Sort(new GenericSort<SomeType>("Value"));

    }

}

class SomeType

{

    privateint _value;


    publicint Value

    {

        get { return _value;
}

        set { _value = value;
}

    }

}