Eigene Controls für Webparteigenschaften

Manchmal erstellt man einen WebPart, der eine spezielle Konfiguration zur Bewältigung seiner Aufgabe benötigt.
Beispielsweise soll er Daten einer Liste in aufbereiteter Form anzeigen.

Nun wäre es schön, wenn die Auswahl der Liste nicht über eine Textbox, in welche man ihren Namen einträgt, erfolgt, sondern über eine Combobox die alle passenden Listen zur Auswahl anbietet.

Hierfür wird ein sogenannter Toolpart verwendet. Ein Toolpart erbt von der Klasse "Microsoft.SharePoint.WebPartPages.ToolPart" und stellt einen selbst definierten Eingabebereich in der Toolbox des Webparts zur Verfügung.

Beispiel für den Aufbau eines Toolparts:

 1 internal class TPWebTemplates:Microsoft.SharePoint.WebPartPages.ToolPart
 2 {
 3     //wird später zum Auslesen des Wertes verwendet
 4     private string inputIDListName;
 5 
 6     public TPWebTemplates()
 7     {
 8         this.Title = "Template";
 9         this.Init += new EventHandler(InitObject);
10     }
11     private void InitObject(object sender, System.EventArgs e)
12     {
13         //eindeutige ID für das Asuwerten des Steuerelementes
14         inputIDListName = this.UniqueID + "messageList";
15     }
16 
17     /// <summary>
18     /// Auslesen der Änderungen
19     /// </summary>
20     public override void ApplyChanges()
21     {
22         WPSample wp1 = (WPSample)
23             this.ParentToolPane.SelectedWebPart;
24 
25         value = Page.Request.Form[inputIDListName];
26         if (!String.IsNullOrEmpty(value)) wp1.ListName = value;
27     }
28 
29 
30     protected override void RenderToolPart(System.Web.UI.HtmlTextWriter output)
31     {
32         output.Write("Template: ");
33         System.Web.UI.WebControls.DropDownList cboToolpart = new System.Web.UI.WebControls.DropDownList();
34 
35         foreach (Microsoft.SharePoint.SPList list in Microsoft.SharePoint.SPContext.Current.Web.Lists)
36         {
37             if (list.Hidden == false) //Nur Listen anzeigen, die nicht versteckt sind
38             {
39                 System.Web.UI.WebControls.ListItem li = new System.Web.UI.WebControls.ListItem();
40                 li.Text = list.Title;
41                 li.Value = list.Title;
42                 cboToolpart.Items.Add(li);
43             }
44         }
45         //Hier kann Code zum Anzeigen eines bereits gewählten Wertes folgen
46     }
47 }            

Dieser Toolpart referenziert jetzt den WebPart WPSample mit der Property ListName. Besser wäre es hier ein enstprechendes Interface zu vereinbaren.

Der WebPart selbst wird ganz "normal" erstellt.
Einziger Unterschied ist die Überladung der Methode "GetToolParts" durch welche wir den Sharepoint über den zusätzlich darzustellenden Toolpart informieren.

Beispiel:

1 public override Microsoft.SharePoint.WebPartPages.ToolPart[] GetToolParts()
2 {
3     List<Microsoft.SharePoint.WebPartPages.ToolPart> parts = new List<Microsoft.SharePoint.WebPartPages.ToolPart>();
4     parts.Add(new Microsoft.SharePoint.WebPartPages.WebPartToolPart());
5     parts.Add(new Microsoft.SharePoint.WebPartPages.CustomPropertyToolPart());
6     parts.Add(new TPWebTemplates());
7     return parts.ToArray();
8 }

Im Ergebniss sieht das dann in etwa so aus:



Denkbar sind auch komplexere Eingaben z.B. für das Erstellen von Datenbankverbindungen oder Abfragen von WebServices.

Nur eine Instanz einer .Net Anwendung

Diese Klasse hilft einen Anwendung nur einmal zu starten.

Der Code prüft ob bereits einen Instanz der Anwendung läuft und bringt diese dann auf Wunsch in den Vordergrund. Die neu gestartete Instanz kann dann über Application.Exit() beendet werden.

Hinweis: Fenster die minimiert oder unsichtbar sind werden nicht in den Fordergrund gebracht. Hier ist die Implementierung der APIAufrufe "GetWindowPlacement" und "SetWindowPlacement" erforderlich.

---

 1 using System;
 2 using System.Windows.Forms;
 3 using System.Runtime.InteropServices;
 4 
 5 
 6 namespace Toolbox
 7 {
 8     /// <summary>
 9     /// This class helps to create a Application which allowed onyl on instance (like word, excel, eg)
10     /// </summary>
11     internal abstract class SingleInstanceManager
12     {
13         //TODO: create your own GUID with GuidGen!!!
14         private const string APPID="{AD0C0725-18BE-4eaa-8FE6-17F0FC14A971}";
15 
16         #region Win32API
17         [DllImport("user32.dll")]
18         private static extern long BringWindowToTop(long hwnd);
19 
20         [DllImport("user32.dll")]
21         private static extern long SetForegroundWindow(long hwnd);
22         #endregion
23 
24         #region Worker
25 
26         /// <summary>
27         /// check whether an other instance of the current application is running
28         /// </summary>
29         /// <returns>
30         /// true if you can start a new instance, 
31         /// false if an instance is running
32         /// </returns>
33         public static bool StartNewApplication()
34         {
35             return StartNewApplication(false);
36         }
37 
38         /// <summary>
39         /// check whether an other instance of the current application is running
40         /// </summary>
41         /// <param name="BringToTop">
42         /// true: the other instance will shown
43         /// false: the other instance will not shown
44         /// </param>
45         /// <returns>
46         /// true if you can start a new instance, 
47         /// false if an instance is running
48         /// </returns>
49         public static bool StartNewApplication(bool BringToTop)
50         {
51             bool retVal = true;
52             System.Threading.Mutex mu = new System.Threading.Mutex(false, APPID);
53 
54             if (mu.WaitOne(0, false) == true)
55             {
56                 //start a new one
57                 retVal = true;
58             }
59             else
60             {
61                 //an instance is running
62                 retVal = false;
63 
64                 if (BringToTop)
65                 {
66                     foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcessesByName(System.Diagnostics.Process.GetCurrentProcess().ProcessName))
67                     {
68                         if (p.Id != System.Diagnostics.Process.GetCurrentProcess().Id)
69                         {
70                             //p.MainWindowHandle;
71                             SetForegroundWindow(p.MainWindowHandle.ToInt64());
72                             BringWindowToTop(p.MainWindowHandle.ToInt64());
73                         }
74                     }
75                 }//end BringToTop
76 
77             }//end Running ?
78             return retVal;
79         }
80         #endregion
81     }
82 }
83 

Screenshoots mit C#

Mit Hilfe des unten verlinkten Code-Snipplets können Screenshots aus eigenen Anwendungen heraus erstellt werden.

Dabei bestehen folgende Möglichkeiten:

• vollständiger Desktop


• aktives Fenster


• benutzerdefinierter Bereich


• anhand des Handels des Fensters

http://dotnet-snippets.de/dns/Snippet_detail.aspx?=434