Daniel's Blog Doing some things in .NET

9Jul/100

MySites Konfiguration “debuggen”

Die MySites in SharePoint 2010 sind sehr auf den Austausch von persönlichen Informationen ausgerichtet. Neu hinzu kommt eine Pinnwand à la Facebook und die Möglichkeit Statusinformationen bereitzustellen, wie auf XING.
Das Aufsetzen von MySites kann jedoch etwas knifflig sein. Ein bekanntes Problem ist z.B. dass der Serviceaccount, der den User Profile Synchronization Services ausführt zwingend zur lokalen Administratorengruppe hinzugefügt werden muss (weitere Informationen dazu gibts auf Fabians Blog).
Deshalb möchte ich hier kurz zusammenfassen auf was man achten muss um MySites zu erstellen und zeigen wie man Fehlerquellen beim synchronisieren auf die Schliche kommt.

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

  • 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:

Kick it on dotnet-kicks.de
14Mai/100

Entwickeln mit Hilfe des Developer Dashboards

Eines der wichtigsten Features für Entwickler im neuen SharePoint 2010 ist das
Developer Dashboard.
Wie man das Developer Dashboard aktiviert habe ich schon hier beschrieben.
Doch wie benutzt man das Feature um seinen Code zu analysieren?

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

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:

Kick it on dotnet-kicks.de
14Apr/100

ShareCamp 2010 / Session

Am Wochenende war das erste Barcamp der SharePoint Community.
Das mit fast 200 Besuchern ausgebuchte Event war ein voller Erfolg bei dem man sich mit anderen SharePoint Enthusiasten austauschen konnte.
Mit über 40 Sessions hatte die Unkonferenz eine Menge zu bieten. Die Vorträge gingen von Konfigurationsthemen, über Workflows bis zu Entwicklungsthemen. Alles sehr ausgewogen.
Eine Kleinigkeit habe ich dennoch zu bemängeln: Ich hätte mir mehr Entwicklersessions gewünscht :D :P .

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

born2share

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.

  Ribbon_Customizing_im_SP2010_-_Daniel_Lindemann.rar (536.7 KiB, 55 hits)

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

Technorati Tags: ,

Kick it on dotnet-kicks.de
15Mrz/102

Bing Maps im Sharepoint

Im aktuellen .NET Magazin ist ein schöner Bericht von Tobias Richling über das Entwickeln von Webanwendungen die geographische Daten per Bing Maps visualisieren.
Dabei benutzt er ein Bing Maps ASP.NET Control, das auf Codeplex veröffentlicht wurde.

Nachdem ich den Artikel durchgelesen habe, dachte ich mir: "Hey, Sharepoint mit Bing Maps ausstatten ... wieso nicht?"
Das Ergebnis lies nicht lange auf sich warten. Deshalb möchte ich hier zeigen wie man Bing Maps per Webpart in den Sharepoint 2010 einbinden kann.

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.

  BingMapsWebpart_SP2010.zip (163.3 KiB, 124 hits)

Technorati Tags: ,

Kick it on dotnet-kicks.de
9Feb/100

Erstes Sharepoint BarCamp

Am 10. und 11.4.2010 veranstaltet die Firma DataOne zusammen mit Microsoft das erste Sharepoint BarCamp in der Microsoft Zentrale in Unterschleißheim.
Ein BarCamp ist eine Art Konferenz bei der es jedoch statt Besuchern nur aktive Teilnehmer gibt. Die einzelnen Sessions werden dabei meist zu beginn des BarCamps aufgenommen und geplant. Jeder Teilnehmer ist dazu aufgefordert eigene Ideen/Sessions vorzuschlagen. Diese müssen nicht zwingend geplant sein. Ich habe selbst schon guten Sessions beigewohnt, die innerhalb von 5min entstanden sind!

born2share

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* :D

Technorati Tags: ,

Kick it on dotnet-kicks.de
19Jan/102

Surfstick / Web’n'Walk Stick als SMS Modem benutzen

blau.de Surfstick
Bei der Entwicklung von Softwarelösungen gibt es immer wieder die Anforderung SMS vom System verschicken zu lassen. Meistens während dem Ablauf eines Eskalationsmodells oder zum Benachrichtigen bei außergewöhnlichen Vorkommnissen oder Fehlern im System (z.B. einem unerwarteten Stillstand einer Produktionsanlage).

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

Gsm Modem Ports

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

Gsm Modem Putty

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:

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 :D :D

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

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: , ,

Kick it on dotnet-kicks.de
14Jan/100

Sharepoint 2010 Developer Dashboard aktivieren

Das Developer Dashboard in Sharepoint 2010 bietet die Möglichkeit den Seitenaufbau nachzuverfolgen.
Die Informationen die das Dashboard anzeigt beziehen sich auf die Seite, die Datenbankaufrufe, die Webservice Aufrufe, usw.

Sharepoint2010DeveloperDashboard

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ü
    Sharepoint2010DeveloperDashboardOnDemandButton

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: , ,

Kick it on dotnet-kicks.de
8Nov/090

Aufrufen von Webservices ohne Webreferenz

Schon öfter hatte ich das Problem, dass ich mehrere unterschiedliche Webservices in meiner Assembly benutzen musste. Kam dann ein Service hinzu musste das ganze Projekt neu deployt werden.
Eine Möglichkeit dieses Problem zu umgehen ist das dynamische Laden der Webservice Description und erstellen einer Webservice Instanz per Reflection.
Um eine Instanz des Webservice erstellen zu können, muss man den Service per .NET CodeDom in eine Assembly laden.

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 ;) .
WSDL

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

Download: Beispiel Projekt

Technorati Tags: , ,

Kick it on dotnet-kicks.de