SP.Ribbon.PageManager.get_instance().get_commandDispatcher().executeCommand(<CommandName>, <OptionalParameters>);

Die Commands kann man sehr gut aus der CMDUI.XML lesen.

Hier ein Beispiel für den Ordner erstellen Dialog:

SP.Ribbon.PageManager.get_instance().get_commandDispatcher().executeCommand("NewFolder",null);

Doch es gibt Abhilfe. Das Team von JetBrains hat vor kurzen die erste Version von dotPeek veröffentlicht. dotPeek ist ein Assembly Browser der sich vor allem durch seine gute Bedienung, ähnlich wie Visual Studio bzw. das Addon ReSharper, von ähnlichen Tools abhebt.

Mehr Infos gibts auf http://www.jetbrains.com/decompiler/ .
Ich denke jeder Entwickler der eine alternative zum .NET Reflector sucht wird mit dotPeek seine Freude haben.

Dazu möchte ich herzlichst gratulieren!
Alles Gute zum 5. Geburtstag dotnet-snippets.de !!!
Und auf viele weitere Jahre!

Die Macher rund um die Community Page haben sich für diesen Anlass auch etwas einfallen lassen. Somit gibt es tolle Preise zu gewinnen. Darunter Visual Studio 2010, Office Professional Plus 2010, ein .NET Pro Abo und viele Bücher.

Das Gewinnspiel läuft von 20.04.2011 bis zum 04.05.2011.
Weiter Info zum Gewinnspiel gibts auf dotnet-snippets.de .

Erweiterte PageComponente

Aber zuerst einmal alles zurück auf Anfang. Zunächst benötigt man eine PageComponente.
Ein PageComponent-Objekt ermöglicht das Interagieren mit dem Ribbon (http://msdn.microsoft.com/en-us/library/ff407303.aspx).

Type.registerNamespace('DL.PostbackRibbon');
// RibbonApp Page Component
DL.PostbackRibbon.PageComponent = function () {
	DL.PostbackRibbon.PageComponent.initializeBase(this);
}
DL.PostbackRibbon.PageComponent.initialize = function () {
	ExecuteOrDelayUntilScriptLoaded(
		Function.createDelegate(
			null,
			DL.PostbackRibbon.PageComponent.initializePageComponent),
		'SP.Ribbon.js');
}
DL.PostbackRibbon.PageComponent.initialize = function (controlId) {
	DL.PostbackRibbon.PageComponent.ControlClientId = controlId;
	ExecuteOrDelayUntilScriptLoaded(
		Function.createDelegate(
			null,
			DL.PostbackRibbon.PageComponent.initializePageComponent),
		'SP.Ribbon.js');
}
DL.PostbackRibbon.PageComponent.initializePageComponent = function () {
	var ribbonPageManager = SP.Ribbon.PageManager.get_instance();
	if (null !== ribbonPageManager) {
		ribbonPageManager.addPageComponent(DL.PostbackRibbon.PageComponent.instance);
		ribbonPageManager
			.get_focusManager()
			.requestFocusForComponent(DL.PostbackRibbon.PageComponent.instance);
	}
}
DL.PostbackRibbon.PageComponent.refreshRibbonStatus = function () {
	SP.Ribbon.PageManager
		.get_instance()
		.get_commandDispatcher()
		.executeCommand(Commands.CommandIds.ApplicationStateChanged, null);
}
DL.PostbackRibbon.PageComponent.ControlClientId = null;

DL.PostbackRibbon.PageComponent.prototype = {
	init: function () {
		// if you have something to initalize
	},
	getFocusedCommands: function () {
		return [];
	},
	getGlobalCommands: function () {
		// Server side commands will show up here
		return getGlobalCommands();
	},
	isFocusable: function () {
		return true;
	},
	canHandleCommand: function (commandId) {
		return commandEnabled(commandId);
	},
	handleCommand: function (commandId, properties, sequence) {
		return handleCommand(commandId, properties, sequence);
	}
}

// Register classes
DL.PostbackRibbon.PageComponent.registerClass('DL.PostbackRibbon.PageComponent', CUI.Page.PageComponent);
DL.PostbackRibbon.PageComponent.instance = new DL.PostbackRibbon.PageComponent();

// Notify and execute jobs
NotifyScriptLoadedAndExecuteWaitingJobs("/_layouts/ListinfoRibbonPostbackCommand/DL.PostbackRibbon.PageComponent.js");

Hier gibt es auch die erste Anpassung die ich gemacht habe.
In Zeile 36 habe ich die Variable ControlClientId erstellt, die später die ID des IPostBackEventHandler hält. Somit wird sichergestellt, dass der richtige Handler benutzt wird.
Zeile 13 und 14 zeigen die angepasste Initialize-Methode, die die Control-ID setzt.
Ansonsten ist es eine einfache PageComponente wie in der MSDN beschrieben.

Das CommandHandler Control

Jetzt die spannende Serverseite. Ich habe ein Cotrol erstellt, das das Interface IPostBackEventHandler implementiert.

public class PostbackRibbonHandler : Control, IPostBackEventHandler
{
	public PostbackRibbonHandler()
	{
		ID = "PostbackRibbonHandler";
	}

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

		// register server side command
		List<IRibbonCommand> cmds = new List<IRibbonCommand>()
		{
			new SPRibbonPostBackCommand("RunPostback", this, "RunPostback", null)
		};

		SPRibbonScriptManager sm = new SPRibbonScriptManager();

		// register the page component
		sm.RegisterInitializeFunction(this.Page,
			"InitPageComponent",
			"/_layouts/ListinfoRibbonPostbackCommand/DL.PostbackRibbon.PageComponent.js",
			false,
			"DL.PostbackRibbon.PageComponent.initialize('" + this.ClientID + "')");

		// enable server registered commands on the page
		sm.RegisterGetCommandsFunction(this.Page, "getGlobalCommands", cmds);
		sm.RegisterCommandEnabledFunction(this.Page, "commandEnabled", cmds);
		sm.RegisterHandleCommandFunction(this.Page, "handleCommand", cmds);
	}

	public void RaisePostBackEvent(string eventArgument)
	{
		// implement PostBack logic
		// by default eventArgument contains the name of the command
	}
}

Im Konstruktor gebe ich dem Control einen Namen, damit man später einen PostBack auf dem Control abfeuern kann. Hier werden auch die Commands sowie die PageComponenten registriert die später von dem Control behandelt werden sollen.
Zeile 25 enthält den wichtigsten Schritt: Das setzen der Control-ID in die PageComponente.

PostBack ausführen

Nun wieder zurück zur PageComponente. In der Methode handleCommand wird der PostBack ausgelöst, der den IPostBackEventHandler triggert.
Dabei wird als Argument ein kleines JSON-Objekt übergeben, das mir die benötigten SharePoint Listen- und Iteminformationen bereitstellt.

handleCommand: function (commandId, properties, sequence) {
	if (commandId === 'RunPostback') {
		if (!CUI.ScriptUtility.isNullOrUndefined(DL.PostbackRibbon.PageComponent.ControlClientId)) {
			var controlId = DL.PostbackRibbon.PageComponent.ControlClientId;
			__doPostBack(controlId.replace('_', '$'), '{"id":"RunPostback","selectedId":' + SP.ListOperation.Selection.getSelectedItems()[0].id + ', "listId":"' + GetCurrentCtx().listName + '"}');
			return true;
		}
		else {
			if (window.console)
				window.console.error('Unable to do a postback. PostBackHandler not found.')
		}
	}
	else {
		return handleCommand(commandId, properties, sequence);
	}
}

Verarbeiten der Daten

Die PostBack Argumente kann man sehr schnell über den JavaScriptSerializer zu einem Objekt umwandeln.
Danach führt man wie gewohnt SharePoint Operationen aus.

In diesem Beispiel setze ich einen neuen Titel für das ausgewählte Dokument.

public void RaisePostBackEvent(string eventArgument)
{
	JavaScriptSerializer jss = new JavaScriptSerializer();
	var args = jss.Deserialize<SPRibbonCommandArgs>(eventArgument);

	switch (args.Id)
	{
		case "RunPostback":
			SPWeb web = SPContext.Current.Web;
			SPList list = web.Lists[args.ListId];
			if (list != null)
			{
				SPListItem item = list.GetItemById(args.SelectedId);
				if (item != null)
				{
					SPField titleField = item.Fields.GetFieldByInternalName("Title");
					item[titleField.Id] = "Mein neuer Titel";
					item.SystemUpdate();
				}
			}
			break;
	}
}

[Serializable]
public class SPRibbonCommandArgs
{
	/// <summary>
	/// Command ID
	/// </summary>
	public string Id { get; set; }

	/// <summary>
	/// ID of the Selected Item
	/// </summary>
	public int SelectedId { get; set; }

	/// <summary>
	/// ID of the List
	/// </summary>
	public Guid ListId { get; set; }
}

Ribbon Erweiterung und Delegate-Control

Dann fehlt ja “nur” noch die Ribbon definition. Diese besteht in meinem Fall aus einem einzelnen Button, der in jeder Dokumentenbibliothek eingeblendet wird.
Klickt man auf den Button wird das Klick-Event an die PageComponente geliefert und diese triggert per PostBack den IPostBackEventHandler.

In diese Datei kann man auch direkt das Delegate-Control registieren, wie in Zeile 34.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
	<CustomAction Id="DL.PostbackCommand" Location="CommandUI.Ribbon" RegistrationId="101" RegistrationType="List">
		<CommandUIExtension>
			<CommandUIDefinitions>
				<CommandUIDefinition Location="Ribbon.Documents.Copies" />
				<CommandUIDefinition Location="Ribbon.Documents.Workflow" />
				<CommandUIDefinition Location="Ribbon.Documents.Groups._children">
					<Group Id="Ribbon.Documents.CustomGroup"
						   Sequence="55"
						   Description="Custom Group"
						   Title="Custom"
						   Template="Ribbon.Templates.Flexible2">
						<Controls Id="Ribbon.Documents.CustomGroup.Controls">
							<Button Id="Ribbon.Documents.CustomGroup.RunPostback"
									Command="RunPostback"
									Image16by16="/_layouts/images/ListinfoRibbonPostbackCommand/runit_32x32.png"
									Image32by32="/_layouts/images/ListinfoRibbonPostbackCommand/runit_32x32.png"
									LabelText="Postback!"
									TemplateAlias="o2"
									Sequence="15" />
						</Controls>
					</Group>
				</CommandUIDefinition>
				<CommandUIDefinition Location="Ribbon.Documents.Scaling._children">
					<MaxSize Id="Ribbon.Documents.Scaling.CustomGroup.MaxSize"
							 Sequence="15"
							 GroupId="Ribbon.Documents.CustomGroup"
							 Size="LargeLarge" />
				</CommandUIDefinition>
			</CommandUIDefinitions>
		</CommandUIExtension>
	</CustomAction>
	<Control Id="AdditionalPageHead" ControlAssembly="ListinfoRibbonPostbackCommand, Version=1.0.0.0, Culture=neutral, PublicKeyToken=098b81014c222ac1" ControlClass="ListinfoRibbonPostbackCommand.Controls.PostbackRibbonHandler"></Control>
</Elements>

That’s it.
Da diese ganze Mischung aus JavaScript, C# und XML auf den ersten Blick wohl etwas unübersichtlich ist gibt es hier noch das fertige Projekt zum Download.
Note: There is a file embedded within this post, please visit this post to download the file.

Möchte man über den Ribbon bzw. mehrere Dialoge einen “Workflow” abbilden ist das Verhalten sehr störend (z.B. wenn ein Benutzer mehrere Dialog öffnen muss um einen bestimmten Status auf ein Element zu setzen).

Die gute Nachricht: Durch das Neuladen der Seite mittels SP.UI.ModalDialog.RefreshPage wird ein POST ausgelöst.
Somit kann man sich die Daten in einem HiddenField speichern. Einfachste Lösung wäre hier ein Delegate-Control, das die ID des selektierten Elemtents wieder ausliest.

Doch wie selektiert man das Element wieder?

Microsoft hat bei der Entwicklung des Userinterfaces schon an alles gedacht. Ich musste allerdings lange suchen, bis ich die richtige Funktion gefunden habe:

ToggleItemRowSelection2(ctxCur, tr, fSelect, fUpdateRibbon)

Die Funktion stammt aus der SharePoint core.js.

Die Parameter:

• ctxCur: Der aktuelle SharePoint Context der Seite
• tr: Das DOM-Objekt der auszuwählenden TableRow
• fSelect: Ein bool-Wert, der angibt ob das Element selektiert oder deselektiert wird
• fUpdateRibbon: bool, Gibt an ob die Command-UI (Ribbon) aktualisiert werden soll

Hier ist ein Ausschnitt aus meiner Lösung. Voraussetzung ist ein HiddenField, das per Klick-Event die ID der selektierten Zeile speichert.

$(function () {
	// add click event to row
	$('tr.ms-itmhover').click(function () {
		var iidAttributeValue = $(this).attr('iid');
		var iid = iidAttributeValue.split(',');
		if (iid.length == 3) {
			$('#thehiddenfieldid').val(iid[1]);	// set selection to hidden field
		}
	});

	// read value from hidden field and reselect the row
	var currentCtx = GetCurrentCtx();	// method from CUI.js
	var itemId = $('#thehiddenfieldid').val();		// get id from hiddenfield
	var jTr = $('tr[iid*=",' + itemId + ',"]:first');	// tr to select

	if (!CUI.ScriptUtility.isNullOrUndefined(currentCtx) && jTr.length > 0) {
		ToggleItemRowSelection2(currentCtx, jTr[0], true, true);
	}
});

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. Diese 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\UI\Shell\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.

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.

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

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

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_BingMapsFeatureFeature.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öchte 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ßzwecke 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.

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*