C#
using System;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.ComponentModel.Design;
using Microsoft.Win32;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;
namespace MyPackageNamespace
{
#region #### MyPackage #######################################################################
#endregion
/// <summary>
/// Diese Klasse implementiert das Package, welches aus dieser Assembly entsteht.
/// Die Mindestanforderungen an eine Klasse, die ein gültiges Visual Studio-Package
/// bereitstellen soll, ist die Implementierung des IVsPackage-Interfaces und die
/// Registrierung von sich selbst mit der Shell.
/// Um diese Anforderungen zu erfüllen nutzt dieses Package eine Helferklasse, die im Managed
/// Package Framework (MPF) definiert ist: Es leitet von der Package-Klasse ab, welche die
/// Implementierung des IVsPackage-Interfaces bietet und benutzt die im Framework definierten
/// Registrierungs-Attribute um sich selbst und seine Komponenten in der Shell zu registrieren:
/// PackageRegistrationAttribute: Dieses Attribut teilt dem PkgDef-Erstellungstool
/// (CreatePkgDef.exe) mit, dass diese Klasse ein Package ist.
/// InstalledProductRegistrationAttribute: Dieses Attribut wird benutzt, um die Informationen
/// zu registrieren, die dieses Package im Hilfe-/Info-Dialog von Visual Studio anzeigt.
/// ProvideMenuRessourceAttribute: Dieses Attribut wird benötigt, damit die Shell weiß, dass
/// mit diesem Package Menüpunkte erstellt werden.
/// ProvideToolWindowAttribute: Dieses Attribut registriert das Toolwindow dieses Packages.
/// </summary>
[PackageRegistration(UseManagedResourcesOnly = true)]
[InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
[ProvideMenuResource("Menus.ctmenu", 1)]
[ProvideToolWindow(typeof(MyToolWindow))]
[Guid(GuidList.guidMyPkgString)]
public sealed class MyPackage : Package
{
#region ---- KONSTRUKTOREN ------------------------------------------------------------------------
#endregion
/// <summary>
/// Standardkonstruktor des Packages.
/// An diesem Punkt kann Initialisierungscode geschrieben werden, der den Visual Studio-
/// Service nicht benötigt, da das Package zu diesem Zeitpunkt zwar erstellt wird aber noch
/// nicht Visual Studio bekannt gemacht worden ist. Der Platz für alle anderen
/// Initialisierungsarbeiten ist in der Initialize-Methode.
/// </summary>
public MyPackage()
{
Debug.WriteLine(String.Format("Entering constructor for: {0}", this.ToString()));
}
#region ---- METHODEN (PROTECTED) -----------------------------------------------------------------
#endregion
#region ---- Package ----
#endregion
/// <summary>
/// Initialisierung des Packages; diese Methode wird direkt nach der Bekanntmachung des
/// Packages aufgerufen, womit sie der Platz für Initialisierungscode ist, der den
/// Visual Studio-Service benötigt.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(String.Format("Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
// Befehlshandler für das Menü hinzufügen (Befehle müssen in .vsct-Datei existieren)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService))
as OleMenuCommandService;
if (null != mcs)
{
// Befehl für den Menüeintrag erstellen
CommandID menuCommandID = new CommandID(GuidList.guidMyCmdSet,
(int)PkgCmdIDList.cmdidBlitzSettings);
MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
mcs.AddCommand(menuItem);
// Befehl für das Toolfenster erstellen
CommandID toolwndCommandID = new CommandID(GuidList.guidMyCmdSet,
(int)PkgCmdIDList.cmdidMyPackageToolwindow);
MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
mcs.AddCommand(menuToolWin);
}
}
#region ---- METHODEN (PRIVATE) -------------------------------------------------------------------
#endregion
/// <summary>
/// Diese Funktion ist ein Callback für die Ausführung eines Befehls wenn der Menüeintrag
/// angeklickt wurde. In der Initialize-Methode ist zu sehen, wie der Menüeintrag an diese
/// Funktion mit Hilfe des OleMenuCommandService-Services und der MenuCommand-Klasse
/// gebunden wird.
/// </summary>
private void MenuItemCallback(object sender, EventArgs e)
{
// MessageBox anzeigen, um anzuzeigen, dass der Befehl erkannt wurde
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
Guid clsid = Guid.Empty;
int result;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox(0, ref clsid,
"Visual Blitz", String.Format("Inside {0}.MenuItemCallback()", this.ToString()),
String.Empty, 0, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_INFO, 0/*=false*/, out result));
}
/// <summary>
/// Diese Funktion wird aufgerufen, wenn der Benutzer den Menüeintrag anklickt, der dass
/// Toolfenster öffnet. In der Initialize-Methode ist zu sehen, wie der Menüeintrag an
/// diese Funktion mit Hilfe des OleMenuCommandService-Services und der MenuCommand-Klasse
/// gebunden wird.
/// </summary>
private void ShowToolWindow(object sender, EventArgs e)
{
// Instanznummer 0 des Fenster erhalten. Dieses Fenster ist eine Einzelinstanz, somit
// ist dies die einzige Instanz. Die letzte Flag ist auf true gesetzt, damit das
// Toolfenster erstellt wird wenn es noch nicht existiert.
ToolWindowPane window = this.FindToolWindow(typeof(MyToolWindow), 0, true);
if (null == window || null == window.Frame)
{
throw new NotSupportedException(Resources.CanNotCreateWindow);
}
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
} // #### MyPackage ##################################################################
}Visual Studio-Package-Hauptklasse mit deutscher Übersetzung (und aufgeräumt)
Nutze aber seit mehr als zwei Jahren noch immer nur blankes netcfg hier und kam damit bis zuletzt recht gut aus.
bin aber auch nicht so der PHP-nerd.
