Die Konfiguration

• Farm/Service Account muss zur Gruppe Administratoren gehören
  Der Benutzer der den User Profile Synchronisation Service ausführt musst zur lokalen Administratorgruppe gehören.
• Zugriffsrechte auf die Sharepoint Datenbank
  Der Benutzer der den User Profile Synchronisation Service ausführt muss Daten in die Datenbank schreiben können.
• Prüfen, dass die Windows Services Forefront Indentity Snychronisation und Forefront Identity Manager laufen
  Nachdem man den User Profile Synchronisation Service gestartet hat (der Start kann bis zu 10min dauern), sollte man sich vergewisser, dass die Windows Services Forefront Indentity Snychronisation Service und Forefront Identity Manager Service gestartet wurden. Dieser werden von dem User Profile Synchronisation Service ausgeführt.
• IIS Reset
  Nach dem Starten des Services sollte man einen IIS Reset durchführen, da man sonst eine System.IO.FileLoadException an den Kopf geworfen bekommt :/
  Komplette Exception anzeigen

  System.IO.FileLoadException: The located assembly's manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)    at Microsoft.Office.Server.UserProfiles.UserProfileConfigManager.InitializeIlmClient(String ILMMachineName, Int32 FIMWebClientTimeOut)     at Microsoft.Office.Server.UserProfiles.UserProfileConfigManager..ctor(UserProfileApplicationProxy userProfileApplicationProxy, Guid partitionID)     at Microsoft.SharePoint.Portal.UserProfiles.AdminUI.ProfileAdminPage.IsProfileSynchronizationRunning()     at Microsoft.SharePoint.Portal.WebControls.UserProfileServiceImportStatisticsWebPart.RenderSectionContents(HtmlTextWriter writer)     at Microsoft.SharePoint.Portal.WebControls.UserProfileServiceImportStatisticsWebPart.RenderWebPart(HtmlTextWriter writer)     at Microsoft.SharePoint.WebPartPages.WebPart.Render(HtmlTextWriter writer)     at System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children)     at System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children)     at System.Web.UI.HtmlControls.HtmlForm.RenderChildren(HtmlTextWriter writer)     at System.Web.UI.HtmlControls.HtmlForm.Render(HtmlTextWriter output)     at System.Web.UI.HtmlControls.HtmlForm.RenderControl(HtmlTextWriter writer)     at System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children)     at System.Web.UI.HtmlControls.HtmlContainerControl.Render(HtmlTextWriter writer)     at System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children)     at System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children)     at Microsoft.SharePoint.WebControls.UnsecuredLayoutsPageBase.RenderChildren(HtmlTextWriter writer)     at System.Web.UI.Page.Render(HtmlTextWriter writer)     at Microsoft.SharePoint.WebControls.UnsecuredLayoutsPageBase.Render(HtmlTextWriter writer)     at System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)
  

• Benötigte Rechte und Daten des Active Directories zu synchronisieren
  Der Benutzer der Daten aus dem Active Directory zieht, braucht das Recht Replicate Directory Changes. Meistens ist das der SharePoint Farm Account, es kann aber auch ein anderer Account angegeben werden.

Weitere Informationen zu diesen Themen findet man auch im Microsoft Technet: http://technet.microsoft.com/en-us/library/ee721049(office.14).aspx

Probleme mit dem Tool Forefront Synchronisation Service Manager lösen

Der Forefront Synchronisation Service Manager ist ein nettes Tool mit dem man die Konfiguration des User Profile Synchronisation Services überprüfen kann.
Man findet das Programm unter C:\Program Files\Microsoft Office Servers\14.0\Synchronization Service\UIShell\miisclient.exe.
Mit diesem Tool hat man die Möglichkeit sich eine Liste der Operationen auf ein Active Directory oder auf eine andere Datenquellen anzuschauen, kann sich Operationen (wie z.B. einen FullImport) starten und sich eine genaue Fehlermeldung anzeigen lassen.

Forefront Identity Manager Client

Um das Programm starten zu können muss der Benutzer in folgenden Gruppen sein:

• FIMSyncBrowse
• FIMSyncJoiners
• FIMSyncOperators
• FIMSyncPasswordSet

Danach startet man das Programm im Context des Service Accounts.

Nun sieht man eine Liste der ausgeführten Aktionen.

Synchronisation Service Manager Übersicht

Um z.B. einen FullImport laufen zu lassen, kann man über Actions -> Run (bzw. STRG+F5) eine Aktion starten.

Synchronisation Service Manager Action

Möchte man wissen, warum eine Synchronisation nicht geklappt hat, kann man sich einfach das Log anschauen.

Synchronisation Service Manager Connection Log

Der Synchronisation Service Manager hat noch einiges mehr zu bieten. Für ein kleines Debugging sollten die beschriebenen Funktionen jedoch ausreichen.

Technorati Tags: SharePoint

Zeit stoppen

In der linken Spalte des Developer Dashboards findet man die Ablaufverfolgung des Requests.
Hier findet man eine Liste von ausgeführten Aktionen mit Angaben zur Dauer der Verarbeitung.
Um eigene Aktionen aufzunehmen benutzt man das Objekt SPMonitoredScope, das sich im Namespace Microsoft.SharePoint.Utilities befindet.
Jeglicher Code, der ausgeführt wird solange eine Instanz von SPMonitoredScope vorhanden ist wird protokolliert.
Deshalb sollte man SPMonitoredScope über usings steuern.

protected void myButton_Click(object sender, EventArgs e)
{
    using (SPMonitoredScope scopeButtonPushed = new SPMonitoredScope("Button action"))
    {
        // dummy sleep action
        Thread.Sleep(5000);
        l.Text = "Meine Daten: ";

        string myData = GenerateLabelData();
        l.Text += myData;
    }
}

Dieser Beispielcode nimmt auf, dass die Aktion "Button action" 5 Sekunden gedauert hat und zeigt die Daten in der Ablaufverfolgung an.

Es besteht auch die Möglichkeit Aktionen zu verschachteln.
Somit kann man eine detaillierte Informationen zu seinem Code bekommen.

protected void myButton_Click(object sender, EventArgs e)
{
    using (SPMonitoredScope scopeButtonPushed = new SPMonitoredScope("Button action"))
    {
        // dummy sleep action
        Thread.Sleep(5000);
        l.Text = "Meine Daten: ";

        string myData = GenerateLabelData();
        l.Text += myData;
    }
}

private string GenerateLabelData()
{
    // z.B. lesen von daten aus einer datenbank
    using (SPMonitoredScope scopeGetData = new SPMonitoredScope("Get user information"))
    {
        // ... und noch ein dummy sleep
        Thread.Sleep(3000);
        return "Daniel Lindemann";
    }
}

In diesem Beispiel wird die Aktion "Get user information" innerhalb der Aktion "Button action" ausgeführt.
Dies erzeugt folgende Ausgabe im Developer Dashboard:

Informationen im Developer Dashboard

Wichtige Ereignisse protokollieren

Auf der rechten Seite des Developer Dashboards findet man die Spalte Assertionen und kritische Ereignisse bzw. Asserts and Critical Events in der englischen Version.
Wie der Name schon verrät können hier kritische Ereignisse überprüft werden.
Man sollte diese Funktion benutzten um darauf hinzuweisen, dass etwas nicht wie gewünscht ausgeführt wurde. Dazu benutzt man die statische Methode AddDataToScope der Klasse SPCriticalTraceCounter die sich ebenfalls im Namespace Microsoft.SharePoint.Utilities befindet.
Als Beispiel ändere ich die Methode GenerateLabelData() sodass ein Eintrag zu den Ereignissen hinzugefügt wird:

private string GenerateLabelData()
{
    // z.B. lesen von daten aus einer datenbank
    using (SPMonitoredScope scopeGetData = new SPMonitoredScope("Get user information"))
    {
        // ... und noch ein dummy sleep
        Thread.Sleep(3000);
        SPCriticalTraceCounter.AddDataToScope(2501, "Database problem", 1, "Database query took long time");
        return "Daniel Lindemann";
    }
}

Als 3. Parameter erhält die Methode ein Flag, das beschreibt um welche Art von Meldung es sich handelt.
Folgende Meldungen sind möglich:

• 1 = Critical
• 4 = Exception
• 6 = Assert
• 8 = Warning
• 10 = Unexpected
• 15 = Monitorable

Diese Methode um den Ablauf des Codes zu verfolgen hat jedoch einen Nachteil. Es wird immer der komplette StackTrace mitgespeichert und somit kann die Antwort des Servers um einige kB anwachsen.
Darum sollte die Methode nicht für jedes Problem das auftreten kann aufgerufen werden.

Technorati Tags: SharePoint

Sollte es nächstes Jahr auch ein ShareCamp geben bin ich wieder mit Freude dabei.

Eindrücke vom ersten ShareCamp gibts auf http://www.sharecamp.de

Ich möchte mich auch nochmal bei allen Besuchern meiner Session zum Thema Ribbon Customizing im SharePoint 2010 bedanken.
Wie versprochen sind hier die Slides und Beispiele.

EDIT: Hatte Probleme mit meinem Webserver. Jetzt funktioniert der Download aber

Technorati Tags: Community, SharePoint

Bing Maps im Sharepoint 2010

Bing Maps ASP.NET Control anpassen

Das Bing Maps ASP.NET Control ist ein Wrapper, der um den Bing Maps Service gelegt wurde. Das Steuerelement gehörte zum Live SDK wurde aber wieder entfernt.
Der Vorteil dieses Steuerelements ist, dass man durch das Setzen von wenigen Eigenschaften eine Bing Map angezeigt bekommt ohne eine Zeile Javascript. Dennoch ist es möglich die angezeigte Karte mittels Bing Maps AJAX SDK zu ändern, was einem Entwickler bei Sharepoint 2010 Projekten sehr entgegen kommt .

Auf Codeplex steht nur der Quellcode des Steuerelements zu Verfügung. Da die Assembly, um sie in Sharepoint benutzen zu können, mit einem Schlüssel signiert sein muss , ist das sogar ein Vorteil.

Wenn man sich den Quellcode geladen hat, kann man die Solution in Visual Studio öffnen und die Assembly signieren. Das Projekt das einen Schlüssel braucht hat den Namen Microsoft.Live.ServerControls.VE.
Ist dieser Schritt erledigt kann man das Projekt neu erstellen. Das benötigte Steuerelement findet man dann im Projektordner unter Source\bin.

Erstellen eines Bing Map Webparts

Um das Bing Maps Webpart zu erstellen, benutzt man am besten die Vorlage für ein normales Webpart (die Vorlage des Visual Webpart finde ich ein wenig oversized).
Nachdem man die Referenz zur Bing Maps Control hinzugefügt hat, muss man im Solution Packet Editor noch die Assembly als SafeControl eintragen, damit sie mit auf den Server deployt wird.
Das Solution Paket sollte danach so aussehen:

<Solution xmlns="http://schemas.microsoft.com/sharepoint/" SolutionId="3dd182a9-21c3-4260-9177-de19e39420fe" SharePointProductVersion="14.0">
  <Assemblies>
    <Assembly Location="Microsoft.Live.ServerControls.VE.dll" DeploymentTarget="GlobalAssemblyCache">
      <SafeControls>
        <SafeControl Assembly="Microsoft.Live.ServerControls.VE, Version=0.1.0.0, Culture=neutral, PublicKeyToken=null" Namespace="Microsoft.Live.ServerControls.VE" TypeName="*" />
        <SafeControl Assembly="Microsoft.Live.ServerControls.VE, Version=0.1.0.0, Culture=neutral, PublicKeyToken=null" Namespace="Microsoft.Live.ServerControls.VE.Extenders" TypeName="*" />
      </SafeControls>
    </Assembly>
    <Assembly Location="BingMapsWebpart_SP2010.dll" DeploymentTarget="GlobalAssemblyCache">
      <SafeControls>
        <SafeControl Assembly="BingMapsWebpart_SP2010, Version=1.0.0.0, Culture=neutral, PublicKeyToken=2cf157c772a0dd57" Namespace="BingMapsWebpart_SP2010.BingMaps" TypeName="*" />
      </SafeControls>
    </Assembly>
  </Assemblies>
  <FeatureManifests>
    <FeatureManifest Location="BingMapsWebpart_SP2010_BingMapsFeature\Feature.xml" />
  </FeatureManifests>
</Solution>

Je nachdem wie man das Webpart benutzen möchte muss man noch die Deployment Eigenschaften anpassen.
Für mein Beispiel benutze ich folgende Einstellungen:

• Deployment der Assemblies im GAC
• Webpart Feature Bereich Site

Zurück zum eigentlichen Thema.
Im Quellcode des Webparts muss man erst einmal feststellen ob ein ScriptManager auf der Seite vorhanden ist, da es sich beim Bing Maps ASP.NET Control um ein Ajax Control handelt. Ist kein ScriptManager auf der Seite vorhanden muss man einen hinzufügen! Am besten überschreibt man dafür die Methode OnInit( ).

protected override void OnInit(EventArgs e)
{
    base.OnInit(e);

    // enables script manager
    ScriptManager sm = ScriptManager.GetCurrent(this.Page);
    if (sm == null)
    {
        // register scriptmanager
        ScriptManager newScriptManager = new ScriptManager() { ID = "bingMapsScriptManager", ScriptMode = ScriptMode.Auto };
        this.Page.Form.Controls.Add(newScriptManager);
    }
}

Fehlt nur noch eine Bing Map. Um diese anzeigen zu lassen erstellt man in der Methode CreateChildControls( ) das Objekt Map. Das Map-Objekt ist das Hauptobjekt das benötigt wird und befindet sich im Namespace Microsoft.Live.ServerControls.VE. Es spiegelt wie der Name schon vermuten lässt eine Bing Map wieder.
Man könnte sich die Map jetzt schon anzeigen lassen. Aber ich möchten den Benutzer gerne auf eine Standardansicht leiten. So kann man mittels der Eigenschaft Dashboard das Bing Maps Menü ein- bzw. ausblenden und die Eigenschaft Center gibt an welchen Punkt das Map-Objekt zu Beginn zentrieren soll.
Dazu gibt es noch viele weitere Eigenschaften auf die ich hier nicht weiter eingehen möchte, da es sehr viele sind.

Der Code um Berlin in der Karte anzeigen zu lassen sieht folgendermaßen aus:

protected override void CreateChildControls()
{
    base.CreateChildControls();

    Map bingMap = new Map() { ID = "bingMap", Height = new Unit(600), Width = new Unit(100.00, UnitType.Percentage) };
    bingMap.ZoomLevel = 10;
    bingMap.Dashboard = true;
    bingMap.Center = new LatLong(52.5070, 13.3615);    // Berlin
    bingMap.Locale = SupportedLocales.de_de;    // UI in deutsch
    bingMap.ScaleBarDistanceUnit = DistanceUnit.Kilometers;    // Maßeinheit in KM

    this.Controls.Add(bingMap);
}

Jetzt kann man das Webpart testen. Einfach das Debuggen starten und das Bing Map Webpart auf einer Seite hinzufügen.

Daten in Bing Map anzeigen

Natürlich kann man sich mit Bing Maps nicht nur eine Karte anzeigen lassen. Wie auch bei vielen anderen Web Map Diensten kann man Punkte auf der Karte hervorheben. Dazu gehören z.B. Punkte auf Objekte, Routen, hervorgehobene Bereiche.
Ermöglicht wird das Ganze im Bing Maps ASP.NET Control durch Shapes. Wenn ich mir also eine Reißzwecken am Brandenburger Tor hinzufügen möchte muss ich ein Shape in Gestalt einer Reißzwecke hinzufügen.

Shape brandenburgerTor = new Shape(ShapeType.Pushpin, new LatLongWithAltitude(52.51625, 13.37767));
brandenburgerTor.Title = "Brandenburger Tor";
brandenburgerTor.Description = "Das Wahrzeichen Berlins";
brandenburgerTor.MoreInfoURL = "http://de.wikipedia.org/wiki/Brandenburger_Tor";
bingMap.AddShape(brandenburgerTor);

Die wichtigesten Informationen muss man im Konstruktor übergeben. ShapeType.Pushpin gibt an, dass der Shape als Reißzwecke gerendert wird. Danach folgen die Koordinaten für das Brandenburger Tor als LatLongWithAltitude-Objekt.
Die Eigenschaften Title, Description und MoreInfoURL geben an was angezeigt werden soll, wenn man mit der Maus über den Reißzwecken fährt.

Ortsmarke in Bing Maps

Fazit

Durch Bing Maps und das Bing Maps ASP.NET Control ist es auf einfache Art und Weise möglich geographische Daten im Sharepoint zu visualieren. Man könnte sich beispielsweise eine Liste mit Konferenzen halten und speichert sich in einem zusätzlichen Feld wo sie statt finden. Für mich ist es zudem eine Abwechslung zu den einfach gehaltenen Listen.
Ob Bing Maps in ASP.NET / Sharepoint Anwendungen eine Zukunft hat wird sich noch zeigen. Mir hat das Entwickeln dieser Beispielapplikation auf jeden fall Spaß gemacht.

Technorati Tags: ASP.NET, SharePoint

Weitere Informationen gibt es auf der Seite [ShareCamp] born2share.
Wenn das mit meiner Übernachtungsmöglichkeit klappt (wovon ich ausgehen), werde ich auf jeden fall dort sein!
Bleibt nur noch abzuwarten ob ich auf dem ShareCamp meine erste Session halten werden und über welches Thema *grübel*

Technorati Tags: Community, SharePoint

Um eine SMS Lösung zu realisieren muss man nicht immer auf teuere GSM Modems / SMS Gateways zurückgreifen. Es reicht schon wenn man einen Surfstick oder Web'n'Walk Stick zu verfügung hat. Diese kann man auch sehr günstig beziehen.

Ich möchte hier erklären, was man beachten muss um einen Surfstick aus einer eigenen Applikation heraus zu steuern, sodass man ihn als GSM Modem zum Verschicken von SMS benutzen kann.

Voraussetzungen

Damit man per Surfstick SMS verschicken kann müssen zwei Voraussetzungen erfüllt sein

• SIM Karte mit der man SMS versenden kann
  eine Kombikarte von T-Mobile ist evtl. nicht dazu geeignet um SMS zu schicken. Meistens sind diese Karten nur zum Surfen geeignet.
• Treiber für Surfstick müssen installiert sein
  Meistens muss dazu ein Programm zum benutzen des Sticks installiert werden (Modem Software). Diese Software darf nicht gestartet sein, wenn man per selbstgeschriebenem Programm SMS versenden möchte, da sie COM Ports blockiert.

Herausfinden welchen COM Port der Stick benutzt

Nachdem man die Treiber für den Stick installiert hat, findet man in dem Geräte-Manager mind. 1 neues serielles Gerät (bei meinem blau.de Surfstick werden 2 Geräte installiert, das GSM Modem und ein Service/Diagnose Anschluss).

Um herauszufinden welcher COM Port benutzt werden muss, öffnet man den COM Port per Telnet Programm und schickt eine Testnachricht hin. Am einfachsten benutzt man dazu PuTTY.
Als Connection Type Serial benutzen und COM Port angeben.
Wenn die Sitzung geöffnet ist schickt man die Nachricht AT. Danach sollte man die Antwort OK erhalten und weiß somit auf welchem Port das GSM Modem läuft .

Sollte keine Eingabe möglich sein oder kein OK zurückgegeben werden muss man einen anderen COM Port öffnen.

AT Commands

Handys und GSM Modems arbeiten mit AT Commands um auf die Mobilfunkfunktionen zuzugreifen. AT steht dabei für Attention.
Ein Command ist sehr simple aufgebaut: AT+Command Parameter.
Als Antwort bekommt man immer ein OK zurück geliefert bzw ein ERROR wenn etwas schief ging.

Ein einfaches Beispiel:
AT+CPIN="1234"   Mit diesem Befehl gibt man seine PIN ein.

Zum senden von SMS benötigt man die folgenden Befehle:

• AT
  Prüfen ob Modem bereit ist
• AT+CPIN=?
  Prüfen ob PIN, PUK, PIN2 oder PUK2 benötigt wird
• AT+CPIN="1234"
  Eingabe von PIN, PUK, PIN2 oder PUK2
• AT+CMGF=1
  Setzt das SMS Format in den Text Modus
• AT+CMGS="+yyyyy" [Enter]
   > Das ist eine Nachricht [STRG-Z]
  Sendet eine SMS Nachricht ohne sie im Speicher zu hinterlegen

Diese Befehle kann man auch super in einer Telnet Session ausprobieren
Wer mehr Informationen zu AT Commands haben möchte, dem kann ich diese Ressourcen ans Herz legen:

• http://www.gsm-modem.de/gsm-modem-faq.html
• http://www.developershome.com/sms/howToSendSMSFromPC.asp
• http://www.developershome.com/sms/atCommandsIntro.asp
• http://www.control.com.sg/at_commands_sms.aspx
• http://www.anotherurl.com/library/at_test.htm

SMS mit .NET versenden

Jetzt sind alle nötigen Informationen gesammelt und man kann mittels .NET einen SerielPort öffnen. Die Einstellungen sind prizipiell egal und können auf dem Stardard stehen bleiben. Einzigst der COM Port, der benutzt werden soll muss eingestellt werden.

// using System.IO.Ports;    nicht vergessen in die Klasse aufzunehmen
SerialPort comport = new SerialPort("COM5");

Als nächsten schickt man dann den Befehl AT um zu sehen ob das GSM Modem bereit ist.
Da man warten muss bis das Modem eine Antwort zurück gibt, lässt man den Thread in dem der Code läuft ein paar ms warten.

comPort.Write("AT" + SpecialCharacter.Return);
Thread.Sleep(50);
string answer = ReadComPort();

Die Methode ReadComPort( ) vereinfacht das lesen und löscht die Puffer des SerialPort, damit man nicht immer alles per Code wiederholen muss.

private string ReadComPort()
{
    try
    {
        return comPort.ReadExisting();
    }
    catch
    {
        return "ERROR";
    }
    finally
    {
        comPort.DiscardInBuffer();
        comPort.DiscardOutBuffer();
    }
}

Ein weiteres kleines Helferlein ist die Struktur SpacialCharacter mit der ich benötigte Schriftzeichen an den SerialPort schicken kann.

public struct SpecialCharacter
{
    public static string CtrlZ = ((char)26).ToString();
    public static string Return = Environment.NewLine;
}

Nun muss man die PIN Nummer eingeben. Dazu schickt man den Befehl AT+CPIN="1234" ab. Ich gehe jetzt davon aus, dass der PIN 1234 lautet .

comPort.Write("AT+CPIN=\"1234\"" + SpecialCharacter.Return);
Thread.Sleep(50);
string answer = ReadComPort();

Gibt das GSM Modem in diesem Schritt wieder OK zurück, kommen wir zum dritten Schritt.
Das setzen des Text Modus mittels AT+CMGF=1.

comPort.Write("AT+CMGF=1" + SpecialCharacter.Return);
Thread.Sleep(50);
string answer = ReadComPort();

Quittiert das Modem den Befehl wiedermal mit OK kommt der finale Schritt. Das senden einer SMS!!!

Der Befehl zum Senden einer SMS ohne die SMS im Speicher zu hinterlegen lautet AT+CMGS="+yyyyy" bei der man die Nummer des Empfängers angibt. Nach dem Absenden des Befehls erwartet das Modem eine weiter Eingabe, die Nachricht, die mit STRG+z bestätigt werden muss.

comPort.Write("AT+CMGS=\"" + PhoneNumber + "\"" + SpecialCharacter.Return);
Thread.Sleep(10);
comPort.Write(Message + SpecialCharacter.CtrlZ);
Thread.Sleep(50);
string answer = ReadComPort();

Ist die Antwort OK hat man eine SMS verschickt und kann sich auf den Empfang freuen

Schön verpacken

Damit der gesamte Ablauf etwas handlicher wird, sollte man den kompletten Vorgang um eine SMS zu verschicken in eine Klasse.
Bei mir kam folgendes heraus:

Kompletten Quelltext anzeigen

using System;
using System.IO.Ports;
using System.Text;
using System.Threading;

namespace EasySms
{
    public class GsmModem : IDisposable
    {
        private string comPortName;
        private int baudRate;
        private Parity parity;
        private int dataBits;
        private StopBits stopBits;

        private SerialPort comPort;

        public GsmModem()
        {
            this.comPortName = string.IsNullOrEmpty(SerialPort.GetPortNames()[0]) ? "COM1" : SerialPort.GetPortNames()[0];
            this.baudRate = 115200;
            this.parity = Parity.None;
            this.dataBits = 8;
            this.stopBits = StopBits.One;

            this.SetUpComport();
            this.comPort.Open();
        }

        public GsmModem(string ComPortName)
        {
            this.comPortName = ComPortName;
            this.baudRate = 115200;
            this.parity = Parity.None;
            this.dataBits = 8;
            this.stopBits = StopBits.One;

            this.SetUpComport();
            this.comPort.Open();
        }

        public GsmModem(string ComPortName, int BaudRate, Parity ComParity, int DataBits, StopBits ComStopBits)
        {
            this.comPortName = ComPortName;
            this.baudRate = BaudRate;
            this.parity = ComParity;
            this.dataBits = DataBits;
            this.stopBits = ComStopBits;

            this.SetUpComport();
            this.comPort.Open();
        }

        public bool ModemReady
        {
            get
            {
                comPort.Write("AT" + SpecialCharacter.Return);
                Thread.Sleep(50);
                string answer = ReadComPort();

                if (answer.ToLower().Contains("ok"))
                    return true;
                else
                    return false;
            }
        }

        public bool SimReady
        {
            get
            {
                comPort.Write("AT+CPIN=?" + SpecialCharacter.Return);
                Thread.Sleep(50);
                string answer = ReadComPort();

                if (answer.ToLower().Contains("ready"))
                    return true;
                else
                    return false;
            }
        }

        public SimState ModemSimState
        {
            get
            {
                comPort.Write("AT+CPIN=?" + SpecialCharacter.Return);
                Thread.Sleep(50);
                string answer = ReadComPort();

                string pre = "+cpin: ";

                if (answer.ToLower().Contains(pre + "ready"))
                    return SimState.READY;
                else if (answer.ToLower().Contains(pre + "sim pin"))
                    return SimState.SIM_PIN;
                else if (answer.ToLower().Contains(pre + "sim puk"))
                    return SimState.SIM_PUK;
                else if (answer.ToLower().Contains(pre + "sim pin2"))
                    return SimState.SIM_PIN2;
                else if (answer.ToLower().Contains(pre + "sim puk2"))
                    return SimState.SIM_PUK2;
                else if (answer.ToLower().Contains(pre + "ph-sim pin"))
                    return SimState.PH_SIM_PIN;
                else if (answer.ToLower().Contains(pre + "blocked"))
                    return SimState.BLOCKED;
                else
                    return SimState.ERROR;
            }
        }

        public Encoding ModemEncoding
        {
            get { return this.comPort.Encoding; }
        }

        private string ReadComPort()
        {
            try
            {
                return comPort.ReadExisting();
            }
            catch
            {
                return "ERROR";
            }
            finally
            {
                comPort.DiscardInBuffer();
                comPort.DiscardOutBuffer();
            }
        }

        private void SetUpComport()
        {
            this.comPort = new SerialPort(this.comPortName, this.baudRate, this.parity, this.dataBits, this.stopBits);
            this.comPort.ErrorReceived += new SerialErrorReceivedEventHandler(comPort_ErrorReceived);
            this.comPort.Encoding = Encoding.Default;
            this.comPort.NewLine = SpecialCharacter.Return;
            this.comPort.ReadTimeout = 2500;
            this.comPort.WriteTimeout = 2500;
        }

        private void comPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
        {
            throw new GsmModemException("Error on " + this.comPortName, e.EventType);
        }

        public string ExecuteATCommand(string Command)
        {
            comPort.Write(Command);
            Thread.Sleep(50);
            return ReadComPort();
        }

        public ModemAnswer SetTextMode(SmsTextMode TextMode)
        {
            comPort.Write("AT+CMGF=" + ((int)TextMode).ToString() + SpecialCharacter.Return);
            Thread.Sleep(50);
            string answer = ReadComPort();

            if (answer.ToLower().Contains("ok"))
                return ModemAnswer.OK;
            else
                return ModemAnswer.ERROR;
        }

        public ModemAnswer SetPin(string Pin)
        {
            comPort.Write("AT+CPIN=\"" + Pin + "\"" + SpecialCharacter.Return);
            Thread.Sleep(50);
            string answer = ReadComPort();

            if (answer.ToLower().Contains("ok"))
                return ModemAnswer.OK;
            else
                return ModemAnswer.ERROR;
        }

        public ModemAnswer SendSms(string PhoneNumber, string Message)
        {
            comPort.Write("AT+CMGS=\"" + PhoneNumber + "\"" + SpecialCharacter.Return);
            Thread.Sleep(10);
            comPort.Write(Message + SpecialCharacter.CtrlZ);
            Thread.Sleep(50);
            string answer = ReadComPort();

            if (answer.ToLower().Contains("ok"))
                return ModemAnswer.OK;
            else
                return ModemAnswer.ERROR;
        }

        public ModemAnswer SendSms(string PhoneNumber, string Message, out string CompleteModemAnswer)
        {
            comPort.Write("AT+CMGS=\"" + PhoneNumber + "\"" + SpecialCharacter.Return);
            Thread.Sleep(10);
            comPort.Write(Message + SpecialCharacter.CtrlZ);
            Thread.Sleep(50);
            string answer = ReadComPort();
            CompleteModemAnswer = answer;

            if (answer.ToLower().Contains("ok"))
                return ModemAnswer.OK;
            else
                return ModemAnswer.ERROR;
        }

        #region IDisposable Member

        public void Dispose()
        {
            if (this.comPort != null && this.comPort.IsOpen)
            {
                this.comPort.Close();
            }

            this.comPort.Dispose();
        }

        #endregion
    }
}

namespace EasySms
{
    public enum ModemAnswer
    {
        OK,
        ERROR
    }

    public enum SmsTextMode
    {
        PDU = 0,
        TEXT = 1
    }

    public enum SimState
    {
        READY,
        SIM_PIN,
        SIM_PUK,
        SIM_PIN2,
        SIM_PUK2,
        PH_SIM_PIN,
        BLOCKED,
        ERROR
    }
}

Durch diese kleine Klasse vereinfacht sich das SMS senden auf folgende paar Zeilen:

using (GsmModem modem = new GsmModem("COM11"))
{
    if (modem.ModemReady)
    {
        if (modem.ModemSimState == SimState.READY)
        {
            string modemAnswer;
            ModemAnswer answer;
            modem.SetTextMode(SmsTextMode.TEXT);
            answer = modem.SendSms("+49160xxxxxxx", "Test von meiner Assembly", out modemAnswer);
            if (answer == ModemAnswer.OK)
            {
                Console.WriteLine("yeah!!!");
                Console.WriteLine(modemAnswer);
            }
            else
            {
                Console.WriteLine("och nööö!!!!");
                Console.WriteLine(modemAnswer);
            }
        }
    }
}

Das komplette Projekt kann man sich hier herunterladen.
Ich denke es ist eine gute Basis und kann leicht erweitet werden.

Technorati Tags: .NET, AT Commands, SMS

Bevor man das Dashboard aktiviert, sollte man wissen, dass es folgende Optionen gibt:

• On - Schaltet das Developer Dashboard an
• Off - Schaltet das Developer Dashboard aus
• OnDemand - Ermöglicht das öffnen des Developer Dashboards über einen Button im Menü
  

Folgende Möglichkeiten gibt es um das Developer Dashboard in Sharepoint zu aktivieren:

• STSADM.EXE
• PowerShell
• Sharepoint Object Model

STSADM.EXE

Eingabeaufforderung (cmd) öffnen und in den Ordner C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\BIN wecheln.
Danach folgenden stsadm.exe mit folgenden Parametern ausführen:

stsadm.exe -o setproperty -propertyname developer-dashboard -propertyvalue On

PowerShell

Nachdem man eine PowerShell geöffnet hat, muss man zuerst die Sharepoint 2010 PowerShell Bibliothek laden:

Add-PSSnapin Microsoft.SharePoint.Powershell

Jetzt kann man einfach folgendes Skript benutzen um das Developer Dashboard zu aktivieren:

$ddb= [Microsoft.Sharepoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings
$ddb.DisplayLevel = "On"
$ddb.TraceEnabled = $true
$ddb.Update()

Sharepoint Object Model

Um das Developer Dashboard mittels Sharepoint Object Model (kurz: Sharepoint OM) muss man mit Visual Studio ein neues Projekt erstellen und danach die Sharepoint OM Assembly als Referenz hinzufügen.
Die Assembly findet man im GAC unter dem Namen Microsoft.Sharepoint.
Der Code, der das Developer Dashboard aktiviert sieht folgendermaßen aus:

SPWebService.ContentService.DeveloperDashboardSettings.DisplayLevel = SPDeveloperDashboardLevel.On;
SPWebService.ContentService.DeveloperDashboardSettings.TraceEnabled = true;
SPWebService.ContentService.DeveloperDashboardSettings.Update();

Bevor das Programm richtig läuft muss die Zielplattform auf x64 umgestellt sein, da man sonst eine NullReferenceException hervorruft (weitere Infos dazu gibts auf René Hézser's Blog).

Have fun with Sharepoint 2010!

Technorati Tags: .NET, PowerShell, SharePoint

Laden der Webservice Description

Die Webservice Description läd man am besten mittels WebClient und der statischen Methode Read( ) des ServiceDescription-Objekts.
Dazu muss ein Verweis auf System.Web.Services hinzugefügt werden.
Zu finden ist die Webservice Description auf der Webservice Seite unter dem Link Dienstbeschreibung. Oder man hängt einfach den Parameter WSDL hinter dem Service Link an .

ServiceDescription description = null;
using (WebClient client = new WebClient())
{
	using (Stream s = client.OpenRead("http://localhost:1044/BundesligaService.asmx?WSDL"))
	{
		description = ServiceDescription.Read(s);
	}
}

Mittels eines ServiceDescriptionImporter muss man den Service zu der Assembly hinzufügen, die man später erstellen möchte.
Also erstellt man sich einfach ein ServiceDescriptionImporter-Objekt und fügt das vorher erstellte ServiceDescription-Objekt zur Auflistung der zu importierenden Service Descriptions hinzu.

// Import Webservice
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.ProtocolName = "SOAP12";
importer.Style = ServiceDescriptionImportStyle.Client;
importer.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
importer.AddServiceDescription(description, null, null);

Erstellen der Webservice Assembly

Damit man eine Webservice Assembly dynamisch erstellen kann, braucht man verschiedene Objekte aus dem System.CodeDom-Namespace. Da wären zuerst einmal die zwei Klassen CodeNamespace und CodeCompileUnit.
CodeNamespace stellt wie der Name schon erahnen lässt einen Namespace dar.
Das CodeCompileUnit-Objekt stellt einen Container für dynamisch erstellten Code bereit.

Jetzt muss man die Service Description in die erstellte CodeCompileUnit importieren. Die Methode Import( ) der ServiceDescriptionImporter-Klasse übernimmt das erstellen des Proxycodes und gibt einen Wert der Enumeration ServiceDescriptionImportWarnings zurück (falls keine Probleme auftraten, ist der Rückgabewert 0).

Nun fehlt noch der Codegenerator. Den erstellt man durch den Aufruf der statischen Methode CreateProvider( ) der CodeDomProvider-Klasse und natürlich generiere ich einen C#-Codegenerator .
Danach hat man noch die Möglichkeit Assemblies zu referenzieren die in der neuen Assembly benutzt werden sollen.

Ist alles erledigt, kann die Assembly erstellt werden. CompileAssemblyFromDom( ) der CodeDomProvider-Instanz kompiliert die Assembly und gibt eine Instanz der Klasse CompilerResults zurück.
Wenn die Errors-Auflistung keine Elemente enthält, verlief das kompilieren der Assembly ohne Probleme. Jetzt kann man mittels der Eigenschaft CompiledAssembly der CompilerResult-Instanz auf die Assembly zugreifen und eine Instance des Webservice erstellen.

// Create new Assembly with DOM
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(codeNamespace);

// Import webservice reference to assembly
object webserviceInstance = null;
ServiceDescriptionImportWarnings warnings = importer.Import(codeNamespace, ccu);
if (warnings == 0)
{
	// Create c# code
	CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");

	// Add some references
	string[] assemblyReferences = new string[] { "System.dll", "System.Web.Services.dll", "System.Web.dll", "System.Xml.dll" };
	CompilerParameters cp = new CompilerParameters(assemblyReferences);
	cp.GenerateInMemory = true; // Save assembly in memory

	// Compile assembly
	CompilerResults results = provider.CompileAssemblyFromDom(cp, ccu);
	if (results.Errors.Count > 0)
		throw new Exception("Can't compile code");
	else
		webserviceInstance = results.CompiledAssembly.CreateInstance("BundesligaService");
}

Eine Webservice Methode ausführen

Um den Webservice zu benutzen lässt man sich einfach per Reflection ein MethodInfo-Objekt von der Webserviceinstanz zurück geben und führt die Methode aus.

MethodInfo mi = webserviceInstance.GetType().GetMethod("GetClubs");
object returnValue = (object)mi.Invoke(webserviceInstance, Args);

Um dem ganzen ein bisschen mehr .NET 2.0 Charme zu verpassen, kann man eine Methode erstellen die einen generischen Typ zurück gibt.
Somit kann man sicher gehen, dass das Ergebnis in den richtigen Typ konvertiert wird.

public <T> InvokeMethod<T>(object[] Args)
{
	MethodInfo mi = webserviceInstance.GetType().GetMethod("GetClubs");
	(T)mi.Invoke(webserviceInstance, Args);
}

Kompletten Quelltext der DynamicWebservice-Klasse anzeigen

using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Net;
using System.Reflection;
using System.Web.Services.Description;

namespace TestApplication.BL
{

    public enum WebserviceProtocol
    {
        Soap,
        Soap12,
        HttpPost,
        HttpGet,
        HttpSoap
    }

    public class DynamicWebservice : IDisposable
    {
        private string serviceName;
        private string methodName;
        private WebserviceProtocol protocol;

        private object webserviceInstance;

        public DynamicWebservice(string ServiceName)
        {
            this.serviceName = ServiceName;
        }

        public DynamicWebservice(string ServiceName, string MethodName)
            : this(ServiceName)
        {
            this.methodName = MethodName;
        }

        public DynamicWebservice(string ServiceName, string MethodName, WebserviceProtocol Protocol)
            : this(ServiceName, MethodName)
        {
            this.protocol = Protocol;
        }

        public void CreateWebserviceAssembly(string serviceUrl)
        {
            // Read WSDL file
            string uri = string.Empty;
            if (serviceUrl.EndsWith(@"/"))
                uri = serviceUrl + "?wsdl";
            else if (serviceUrl.EndsWith("asmx"))
                uri = serviceUrl + "?wsdl";
            else
                uri = serviceUrl + @"/?wsdl";

            ServiceDescription description = null;
            using (WebClient client = new WebClient())
            {
                using (Stream s = client.OpenRead(uri))
                {
                    description = ServiceDescription.Read(s);
                }
            }

            // Import Webservice
            ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
            importer.ProtocolName = this.protocol.ToString();
            importer.Style = ServiceDescriptionImportStyle.Client;
            importer.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
            importer.AddServiceDescription(description, null, null);

            // Create new Assembly with DOM
            CodeNamespace codeNamespace = new CodeNamespace();
            CodeCompileUnit ccu = new CodeCompileUnit();
            ccu.Namespaces.Add(codeNamespace);

            // Import webservice reference to assembly
            ServiceDescriptionImportWarnings warnings = importer.Import(codeNamespace, ccu);
            if (warnings == 0)
            {
                // Create c# code
                CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");

                // Add some references
                string[] assemblyReferences = new string[] { "System.dll", "System.Web.Services.dll", "System.Web.dll", "System.Xml.dll" };
                CompilerParameters cp = new CompilerParameters(assemblyReferences);
                cp.GenerateInMemory = true; // Save assembly in memory

                // Compile assembly
                CompilerResults results = provider.CompileAssemblyFromDom(cp, ccu);
                if (results.Errors.Count > 0)
                    throw new Exception("Can't compile code");
                else
                    this.webserviceInstance = results.CompiledAssembly.CreateInstance(this.serviceName);

            }
        }

        public void InvokeMethod(object[] Args)
        {
            if (string.IsNullOrEmpty(this.methodName))
                throw new ArgumentException("No method name declared by the constructor!");

            // Invoke Method
            MethodInfo mi = webserviceInstance.GetType().GetMethod(this.methodName);
            mi.Invoke(webserviceInstance, Args);
        }

        public void InvokeMethod(string MethodName, object[] Args)
        {
            MethodInfo mi = webserviceInstance.GetType().GetMethod(MethodName);
            mi.Invoke(webserviceInstance, Args);
        }

        public object InvokeMethodWithReturnValue(string MethodName, object[] Args)
        {
            MethodInfo mi = webserviceInstance.GetType().GetMethod(MethodName);
            return mi.Invoke(webserviceInstance, Args);
        }

        public T InvokeMethodWithReturnValue<T>(string MethodName, object[] Args)
        {
            MethodInfo mi = webserviceInstance.GetType().GetMethod(MethodName);
            return (T)mi.Invoke(webserviceInstance, Args);
        }

        public void Dispose()
        {
            // delete the instance
            this.webserviceInstance = null;

            this.serviceName = null;
            this.methodName = null;
        }

    }

}

Download: Beispiel Projekt

Technorati Tags: .NET, Reflection, Webservices