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!
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* ![]()
Surfstick / Web’n'Walk Stick als SMS Modem benutzen

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

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

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

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



