Sharepoint 2010 bietet nun endlich ein recht sauberes Design an, was Layout und Inhalt angeht. So ist es möglich über die Masterpage ein grundlegendes Layout für Sharepoint Seiten zu hinterlegen. Wie das geht, das zeigt nun folgende Anleitung.

Schritt 1 - Duplizieren der vorhandenen Masterpage

Die Masterpage dupliziert man am Besten über den Sharepoint Designer. Hierzu ruft man mit einem entsprechendem Designer Benutzer über die Startseite ->"Site Actions"->Sharepoint Designer auf.

Danach wählt man die Einstellungsmöglichkeit "Master Pages" und bekommt 3 bereits vorhandene Masterpages angezeigt:

Für Shareppoint 2010 ist die Masterpage v4.master relevant (Ausnahme: wenn die Kompatibilitätsfunktion SP2007 genutzt werden soll, dann wäre das der default.master). Es empfiehlt sich die Masterpage zu duplizieren, um so wenig Einfluss auf den SP2010 Standard zu nehmen. Das Duplizieren erreicht man durch Markieren des Originals, dann durch Auswahl von Copy (über das Kontextmenü oder über die Ribbon Leiste "Clipboard") und anschließendem Paste (analog zu Copy auffindbar). Es wird eine Kopie erstellt, die nun noch umbenannt werden kann (Kommando Rename über das Kontextmenü oder über die Ribbon Leiste "Edit").

Wo werden nun die Dateien abgelegt? -> Prinzipiell ist es nicht wichtig, ich komme im "Schritt 3 - Einbinden der neuen Masterpage" darauf. Es gibt hier 2 Unterscheidungen. Die Templates, die genutzt werden, sobald ein neues Sharepoint Portal angelegt wird befinden sich unter Windows:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\GLOBAL (englisches Betriebssystem!). Die duplizierte Masterpage befindet sich in der Sharepoint Datenbank (nicht auf Festplatte!).

Schritt 2 - Editieren der neuen Masterpage

Anschließend ist es möglich die neue Masterpage durch Auswahl des Kommandos EditFile (Ribbon Leiste "Edit") oder EditFile in advanced mode (Kontextmenü) zu editieren. Der "advanced mode" bedeutet hier lediglich, dass Sharepoint Standardeinstellungen im HTML Header ebenfalls editierbar sind. Ohne "advanced mode" kann man diese Stellen nicht verändern. Mein Ziel war es jQuery fest in allen Seiten verfügbar zu machen. Hierfür bietet SP2010 eine Möglichkeit über SciptLink das JavaScript einzubinden. Die genauen Details zum Thema ScriptLink werde ich nun hier nicht erläutern, Ziel hier ist es eine modifizierte Masterpage zu erzeugen.

Schritt 3 - Einbinden der Masterpage in Sharepoint-Seiten

1. Man wählt die Website-Masterpage aus. Wie das geht kann man z.B. hier nachlesen: Mirjams Blog - Deploying a custom master page (im letzten Teil des Eintrages).
2. Man verändert die Seiten direkt

• Den Sharepoint Designer für die Webseite öffnen (siehe oben)
  
• Die Auswahl "All Files" auswählen

Schritt 4 - Fazit

Es gibt eine versteckte Möglichkeit bei Microsoft VPC die Synchronisation der Uhrzeit zwischen der virtuellen Maschine und dem Host zu unterbinden. Hierzu muss lediglich an entsprechender Stelle in der *.vmc Datei ein Eintrag platziert werden:

<preferences> 
 <integration> 
  <microsoft> 
   <components> 
    <host_time_sync> 
     <enabled type="boolean">false</enabled> 
    </host_time_sync> 
   </components> 
  </microsoft> 
 </integration> 
</preferences>

Natürlich sollte darauf geachtet werden, dass keine vorhandenen Knoten überschrieben, sondern nur ergänzt werden.

    private static void SearchPattern(string strPattern, string strSearchString)
    {
      int startIndex = 0;
      int contentIndex = strSearchString.Length - 1;

      while (startIndex < contentIndex && startIndex != -1)
      {
        startIndex = strSearchString.IndexOf(strPattern, startIndex);
        if (startIndex != -1)
          startIndex = startIndex + strPattern.Length;
      }
    }

startIndex = strSearchString.IndexOf(strPattern, startIndex,StringComparison.Ordinal);

using System;

/// <summary>
/// Die wunderbare und einzigartige Struktur einer atemberaubenden Singleton.
/// Partial deshalb, weil die Klassendefinition immer mehr und mehr erweitert
/// werden wird.
/// </summary>
public partial class Bianca
{
    /// <summary>
    /// Die einzigartige Instanz.
    /// </summary>
    private static Bianca m_EinzigartigeBianca = new Bianca();

    /// <summary>
    /// Bianca gehört zur Rehl Family und es kann nur über die
    /// Singleton Instanz auf sie zugegriffen werden.
    /// </summary>
    private Bianca()
    {
    }

    /// <summary>
    /// Liefert den Zustand, ob Bianca hungrig ist.
    /// </summary>
    public bool IstHungrig
    {
        get { return GetWunderlicheAntwortObHungrig(); }
    }

    /// <summary>
    /// Liefert den Zustand, ob Bianca gerade schläft.
    /// </summary>
    public bool SchlaeftGerade
    {
        get
        {
            return (!IstHungrig && AugenZu && GleichmaessigeAtmung);
        }
    }

    /// <summary>
    /// Die wunderliche Antwort auf die Frage, ob Bianca hungrig ist
    /// liefert nur die Singleton Instanz mit Hilfe von inneren Zuständen,
    /// die on außen nicht einsehbar sind.
    /// (Trotz .Net und Reflection keine Chance ;-)
    /// </summary>
    /// <returns>True, wenn hungrig, andernfalls False.</returns>
    private bool GetWunderlicheAntwortObHungrig()
    {
        // Miracle, obscure and strange code here
    }
}

SELECT SysObjects.[Name] as TableName, SysColumns.[Name] as ColumnName, SysTypes.[Name] As DataType, SysColumns.[Length] As Length
FROM SysObjects
INNER JOIN SysColumns ON SysObjects.[Id] = SysColumns.[Id]
INNER JOIN SysTypes ON SysTypes.[xtype] = SysColumns.[xtype]
WHERE SysObjects.[type] = 'U'
ORDER BY SysObjects.[Name]

    /// <summary>
    /// Visualisiert ein Dictionary in einer Debug Session.
    /// </summary>
    public class DictionaryVisualizer : DialogDebuggerVisualizer
    {
        /// <summary>
        /// Zeigt einen modalen Dialog, das den Inhalt des Dictionaries visualisiert.
        /// </summary>
        /// <param name="windowService">Der Windows Context, in dem der Debugger läuft.</param>
        /// <param name="objectProvider">Das Dictionary-Objekt, das visualisiert werden soll.</param>
        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            IDictionary dictToShow = null;
            
            // Versuchen, das Objekt aus dem Debugger zu extrahieren
            try
            {
                dictToShow = objectProvider.GetObject() as IDictionary;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    String.Format("Folgender Fehler ist aufgetreten:\n{0}\nStack:\n{1}", ex.Message, ex.StackTrace),
                    "Fehler",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error);

                // Fehler werden ausgegebenund weitere Schritte werden ignoriert
                dictToShow = null;
            }

            // Dictionary anzeigen lassen
            if (dictToShow != null)
            {
                using (frmDictionaryVisualizer dialog = new frmDictionaryVisualizer())
                {
                    dialog.Data = DataTableConverter.ConvertFromDictionary(dictToShow);
                    windowService.ShowDialog(dialog);
                    objectProvider.ReplaceObject(DataTableConverter.ConvertToIDictionary(dialog.Data, dictToShow.GetType()));
                }
            }
        }
    }

    public class DictionarySource : VisualizerObjectSource
    {
        public override void GetData(object target, System.IO.Stream outgoingData)
        {
            IDictionary dictToSerialize = target as IDictionary;
            if (dictToSerialize != null)
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(outgoingData, dictToSerialize);
            }
        }
    }

[assembly: System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
           typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
           Target = typeof(System.Collections.DictionaryBase),
           Description = "Visualize IDictionary")]
[assembly: System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
           typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
           Target = typeof(System.Collections.Hashtable),
           Description = "Visualize IDictionary")]
[assembly: System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
           typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
           Target = typeof(System.Collections.Specialized.ListDictionary),
           Description = "Visualize IDictionary")]
[assembly: System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
           typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
           Target = typeof(System.Collections.Specialized.HybridDictionary),
           Description = "Visualize IDictionary")]
[assembly: System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
           typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
           Target = typeof(System.Collections.Specialized.OrderedDictionary),
           Description = "Visualize IDictionary")]
[assembly: 
System.Diagnostics.DebuggerVisualizer(typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionaryVisualizer),
          
 typeof(Rehl.DebuggingTools.DictionaryVisualizer.DictionarySource),
          
 Target = typeof(System.Collections.Generic.Dictionary<,>),
          
 Description = "Visualize IDictionary")]

string s = "OnlyToStopDebugger!";

    [Serializable]
    public class InheritanceTestClass : Hashtable, ISerializable
    {
        public InheritanceTestClass()
            : base()
        {
        }

        public InheritanceTestClass(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
    }