using System;
using MYCOMPANY.HelperFromHell;

namespace MYCOMPANY.Management.HR.HellWeDontWantThis
{
    public class IncreaseSalary
    {
        private string m_id;
        private decimal m_salary;

        public IncreaseSalary(string idNumberOfEmployee, decimal currentSalary)
        {
            m_id = idNumberOfEmployee;
            m_salary = currentSalary;
        }

        /// <summary>
        /// This is the increase of salary done by HR from time to time.
        /// </summary>
        /// <returns>New salary.</returns>
        public decimal IncreaseItsHr()
        {
            return m_salary;
        }

        /// <summary>
        /// Employee request a higher salary.
        /// </summary>
        /// <param name="whatEmployeeWants">Increase that results from the fucking brain of our brain dead employee.</param>
        /// <returns>New increased salary.</returns>
        public decimal OhNoEmployeeWantsMoreMoneyHowCouldThatHappen(decimal whatEmployeeWants)
        {
            if (Math.Sign(whatEmployeeWants) == 1)
            {
                m_salary = HrHelperFromHell.DoSomeSalaryMagic(m_salary);
                throw new ArgumentOutOfRangeException("whatEmployeeWants", whatEmployeeWants, "The increase is to high! HR Manager was brought to hospital.");
            }
            else
            {
                m_salary += whatEmployeeWants;
            }

            return m_salary;
        }
    }
}

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>

</xs:schema>

<?xml version="1.0" encoding="utf-8"?>
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />

</xs:schema>

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>

</xs:schema>

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>

</xs:schema>

public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es ein inneres Element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced' veweist-->
  <xs:complexType name="TestInnerLink">
    <xs:sequence>
      <xs:element name="ComplexInnerElement" type="ComplexTypeWhichIsReferenced" />
    </xs:sequence>
  </xs:complexType>
</xs:schema>

public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}

        /// <summary>
        /// Methode, die ein XML Schema erweitert, so dass keine ClassType ohne Element existieren,
        /// das darauf verweist.
        /// </summary>
        /// <remarks>Verhindert die Warnung:
        /// cannot generate classes because no top-level elements with complex type were found.</remarks>
        /// <param name="xsdFullFilename">Der voll qualifizierte Dateiname zur XSD Schemadatei.</param>
        /// <param name="throwError">Definiert, ob im Fehlerfall eine Exception geworfen werden soll.</param>
        /// <returns>True, wenn die Erweiterung der Schemadatei erfolgreich war, andernfalls False.</returns>
        public static bool GenerateDummyElementsForClassTypes(string xsdFullFilename, bool throwError)
        {
            XmlDocument schemaDoc = null;
            bool retVal = false;
            List<string> rootElements = new List<string>();
            Dictionary<string, string> rootElementsToAddToSchema = new Dictionary<string, string>();

            try
            {
                // Überprüfung, ob Schemadatei vorhanden
                if (!System.IO.File.Exists(xsdFullFilename))
                {
                    throw new System.IO.FileNotFoundException(String.Format("Konnte die Datei '{0}' nicht finden!", xsdFullFilename));
                }

                // Versuch das Schema in ein XmlDokument zu laden
                schemaDoc = new XmlDocument();
                schemaDoc.Load(xsdFullFilename);

                // Alle Root-Elements herausfinden
                ExtractAllElements(schemaDoc, rootElements);

                // Alle Root-ComplexTypes herausfinden
                ExtractAllClassTypes(schemaDoc, rootElements, rootElementsToAddToSchema);

                // Alle vorgemerkten Root-Elements dem Schema hinzufügen
                AddNecessaryRootElementsToSchemafile(xsdFullFilename, schemaDoc, rootElementsToAddToSchema);

                retVal = true;
            }
            catch
            {
                // wenn gewünscht, dann Fehler schmeißen, ansonsten nur den
                // Rückgabewert auf "False" setzen.
                if (throwError)
                {
                    throw;
                }
                retVal = false;
            }

            return retVal;
        }

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es ein inneres Element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced' veweist-->
  <xs:complexType name="TestInnerLink">
    <xs:sequence>
      <xs:element name="ComplexInnerElement" type="ComplexTypeWhichIsReferenced" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="RootElement0" type="SimpleRootElement" />
  <xs:element name="RootElement1" type="TestInnerLink" />
</xs:schema>

public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}

public partial class ComplexTypeWhichIsReferenced {
    
    private string commonInnerElement1Field;
    
    /// <remarks/>
    public string CommonInnerElement1 {
        get {
            return this.commonInnerElement1Field;
        }
        set {
            this.commonInnerElement1Field = value;
        }
    }
}

public enum SimpleRootElement {
    
    /// <remarks/>
    TestVal1,
    
    /// <remarks/>
    TestVal2,
}

public partial class TestInnerLink {
    
    private ComplexTypeWhichIsReferenced complexInnerElementField;
    
    /// <remarks/>
    public ComplexTypeWhichIsReferenced ComplexInnerElement {
        get {
            return this.complexInnerElementField;
        }
        set {
            this.complexInnerElementField = value;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Reflection;

namespace Testing.MockObjects
{
    /// <summary>
    /// Hilfsklasse, um SQL Exceptions zu generieren. Diese Klasse bietet nur statische
    /// Methoden an.
    /// </summary>
    public class MockSqlException
    {
        #region Constructor

        /// <summary>
        /// Standard Konstruktor, nicht öffentlich, da nur statische Methoden verfügbar sein sollen.
        /// </summary>
        protected MockSqlException()
        {}

        #endregion

        #region Public methods

        /// <summary>
        /// Erstellt eine SqlException über Reflection.
        /// </summary>
        /// <param name="errorMessage">Die Fehlermeldung, die für die SqlException.Message
        /// Eigenschaft vorgesehen werden soll.</param>
        /// <param name="errorNumber">Die Sqlspezifische Fehlernummer.</param>
        /// <returns>Die generierte SqlException.</returns>
        public static SqlException CreateSqlException(string errorMessage, int errorNumber)
        {
            // Eine SqlException enthält immer eine SqlErrorCollection
            SqlErrorCollection collection = GetErrorCollection();

            // Wir brauchen nur einen Fehler, den wir hiermit generieren
            SqlError error = GetError(errorNumber, errorMessage);

            // Dieser Fehler wird der Collection über die Eigenschaft "add" hinzugefügt
            MethodInfo addMethod = collection.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
            addMethod.Invoke(collection, new object[] { error });

            // Hier wird der Konstruktor der SqlException aufgerufen und die SqlErrorCollection
            // als Parameter übergeben (Standard Konstruktor)
            Type[] types = new Type[] { typeof(string), typeof(SqlErrorCollection) };
            object[] parameters = new object[] { errorMessage, collection };
            ConstructorInfo constructor = typeof(SqlException).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
            SqlException exception = (SqlException)constructor.Invoke(parameters);

            // Die SQLException wird zurückgegeben
            return exception;
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Generiert über Reflection einen SqlError, der einer SqlErrorCollection hinzugefügt werden kann.
        /// </summary>
        /// <param name="errorCode">Die Sqlspezifische Fehlernummer.</param>
        /// <param name="message">>Die Fehlermeldung, die für die SqlException.Message
        /// Eigenschaft vorgesehen werden soll.</param>
        /// <returns>Das generierte SqlError Objetkt.</returns>
        private static SqlError GetError(int errorCode, string message)
        {
            // generiert über den Konstruktor und dessen Argumente eine SqlError Instanz
            object[] parameters = new object[] { errorCode, (byte)0, (byte)10, "server", message, "procedure", 0 };
            Type[] types = new Type[] { typeof(int), typeof(byte), typeof(byte), typeof(string), typeof(string), typeof(string), typeof(int) };
            ConstructorInfo constructor = typeof(SqlError).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
            
            return  (SqlError)constructor.Invoke(parameters);
        }
        
        /// <summary>
        /// Generiert über Reflection eine leere SqlErrorCollection Instanz.
        /// </summary>
        /// <returns>Die generierte SqlErrorCollection Instanz.</returns>
        private static SqlErrorCollection GetErrorCollection()
        {
            // generiert über den Konstruktor eine SqlErrorCollection Instanz
            ConstructorInfo constructor = typeof(SqlErrorCollection).
            GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { }, null);
            SqlErrorCollection collection = (SqlErrorCollection)constructor.Invoke(new object[] { });

            return collection;
        }

        #endregion
    }
}

        static void Main(string[] args)
        {
            try
            {
                throw MockSqlException.CreateSqlException(
                    "The conversion from datetime data type to smalldatetime data type resulted in a smalldatetime overflow error",
                    298);
            }
            catch (SqlException sqlex)
            {
                int test = sqlex.ErrorCode;
                Console.WriteLine(String.Format("Eine SQL Exception ist aufgetreten: ErrorCode: {0} Message {1}", sqlex.Number, sqlex.Message));
            }

            Console.WriteLine("If this is displayed, a sql exception was thrown, and everything is fine ;-)");
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XslTransform trans = new XslTransform();
            trans.Load("XSLTFile1.xslt");
            trans.Transform(doc, null, swriter);
        }

<!DOCTYPE xsl:stylesheet [ <!ENTITY jquerysrc SYSTEM 'test.js'> ]>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml" indent="yes"/>

    <xsl:template match="@* | node()">
        <xsl:copy>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>

        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load("XSLTFile1.xslt");
            trans.Transform(doc, null, swriter);
        }

        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XmlReaderSettings xmlReadSet = new XmlReaderSettings();
            xmlReadSet.ValidationType = ValidationType.DTD;
            xmlReadSet.DtdProcessing = DtdProcessing.Parse;

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load(XmlReader.Create("XSLTFile1.xslt", xmlReadSet));
            trans.Transform(doc, null, swriter);
        }

        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XmlReaderSettings xmlReadSet = new XmlReaderSettings();
            xmlReadSet.DtdProcessing = DtdProcessing.Parse;
            xmlReadSet.ValidationType = ValidationType.Schema;

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load(XmlReader.Create("XSLTFile1.xslt", xmlReadSet));
            trans.Transform(doc, null, swriter);
        }

1. Zufallszahlen in einer Schleife
2. Ausgabe von Text in einer Datei ohne Zeilenumbruch
3. Ermitteln von Dateigrößen
4. In Aufrufverzeichnis wechseln (und wieder zurück)
   

FOR /L %%i in (1,1,5) DO (
    SET /A rnd=10*%random%/32768
    ECHO Zahl: %rnd%
)

FOR /L %%i in (1,1,5) DO (
    CALL :ZWISCHENCALL
)
GOTO :EOF

:ZWISCHENCALL
    SET /A rnd=10*%random%/32768
    ECHO Zahl: %rnd%
GOTO :EOF

set /p =TextToDumpIntoFile;<nul>> Result.csv

set /p %%userinput=Bitte Text eingeben:

for /f "delims=" %%i in ('dir FileToCheck.txt /s /B') do (
    if !%%~zi!==!1396! (
        REM Do whatever you want
    )
)

REM wechselt ins Ausführungsverzeichnis
PushD "%~dp0"

REM hier kann z.B. ein externes Tool, was im selben Verzeichnis wie die Batch Datei liegt, aufgerufen werden.

REM wechselt ins Aufrufverzeichnis zurück
PopD

• Ein Testfall erzeugt durch Systemzeitumstellungen definierte Einträge in verschiedene Ereignisprotokolle.
• Nach jedem Schreiben gibt es im Testframework eine Sicherheitsüberprüfung, ob der Eintrag vorhanden ist.
• Nachdem alle Einträge geschrieben wurden, wird meine Komponente getestet, dessen Aufgabe es ist Ereignisse von verchiedenen Rechnern und Ereignisprotokollen zu holen.
• Aufgrund der hohen Datenmengen werden die Ereignisse zeitscheibenweise per WMI abgeholt (siehe auch: Blog Rehl - Quota violation)
  

                    ManagementObjectSearcher searcher = null;
                    ManagementScope scope = null;
                    SelectQuery query = null;

                    // Vorbereitungen und WMI Query Objekt Initialisierungen
                    searcher = new ManagementObjectSearcher();
                    scope = new ManagementScope(string.Format("\\\\{0}", computerName));
                    scope.Path = new ManagementPath("root\\CIMV2");
                    scope.Path.Server = computerName;
                    scope.Connect();
                    searcher.Scope = scope;
                    query = new SelectQuery();

                    // Datum WMI gerecht umwandeln
                    strIntervalStartTime = ManagementDateTimeConverter.ToDmtfDateTime(intervalStartTime);
                    strIntervalEndTime = ManagementDateTimeConverter.ToDmtfDateTime(intervalEndTime);

                    // Hiermit werden die Eventlogs ausgelesen
                    query.QueryString = string.Format("SELECT * FROM Win32_NTLogEvent WHERE (LogFile = '{0}' And TimeGenerated > '{1}' And TimeGenerated < '{2}')", eventLog, strIntervalStartTime, strIntervalEndTime);

                    // Die Abfrage dem Suchobjekt zuweisen
                    searcher.Query = query;

                    // Ergebnisse ermitteln
                    retVal = searcher.Get();

                EventLog log = new EventLog(eventLog, computerName);
                foreach (EventLogEntry entry in log.Entries)
                {
                    if (entry.TimeGenerated > startTime && entry.TimeGenerated < endTime)
                    {
                        retVal = false;
                        break;
                    }
                }