private InterfaceType OleService <InterfaceType>(Type serviceType)
where InterfaceType : class
{
Guid serviceGuid = serviceType.GUID;
Guid interfaceGuid = typeof(InterfaceType).GUID;
IntPtr unknown = IntPtr.Zero;
InterfaceType service = null;
int hr = psp.QueryService(ref serviceGuid, ref interfaceGuid, out unknown);
if (hr != VSConstants.S_OK)
{
Marshal.ThrowExceptionForHR(hr);
}
try
{
service = (InterfaceType)Marshal.GetObjectForIUnknown(unknown);
}
finally
{
if (unknown != IntPtr.Zero)
{
Marshal.Release(unknown);
}
}
return(service);
}
internal static object GetService(Microsoft.VisualStudio.OLE.Interop.IServiceProvider serviceProvider, Guid guidService, bool unique)
{
Guid guidInterface = VSConstants.IID_IUnknown;
IntPtr ptrObject = IntPtr.Zero;
object service = null;
int hr = serviceProvider.QueryService(ref guidService, ref guidInterface, out ptrObject);
if (hr >= 0 && ptrObject != IntPtr.Zero)
{
try
{
if (unique)
{
service = Marshal.GetUniqueObjectForIUnknown(ptrObject);
}
else
{
service = Marshal.GetObjectForIUnknown(ptrObject);
}
}
finally
{
Marshal.Release(ptrObject);
}
}
return(service);
}
protected override object GetServiceImpl(Guid serviceGuid)
{
IntPtr zero = IntPtr.Zero;
Guid unk = new Guid("00000000-0000-0000-c000-000000000046");
Guid self = new Guid("6d5140c1-7436-11ce-8034-00aa006009fa");
if (serviceGuid == self)
{
return(this);
}
int status = _psp.QueryService(ref serviceGuid, ref unk, out zero);
if (status < 0)
{
if ((status == -2147467259) || (status == -2147467262))
{
return(null);
}
Marshal.ThrowExceptionForHR(status);
}
object objectForIUnknown = Marshal.GetObjectForIUnknown(zero);
Marshal.Release(zero);
return(objectForIUnknown);
}
protected void SetWaitCursor()
{
if (this.site != null)
{
IVsHierarchy service = this.GetService(typeof(IVsHierarchy)) as IVsHierarchy;
if (service != null)
{
Microsoft.VisualStudio.OLE.Interop.IServiceProvider ppSP = null;
if (service.GetSite(out ppSP) == 0)
{
IntPtr ptr;
Guid gUID = typeof(SVsUIShell).GUID;
Guid riid = typeof(IVsUIShell).GUID;
if (ErrorHandler.Succeeded(ppSP.QueryService(ref gUID, ref riid, out ptr)))
{
IVsUIShell objectForIUnknown = Marshal.GetObjectForIUnknown(ptr) as IVsUIShell;
if (objectForIUnknown != null)
{
objectForIUnknown.SetWaitCursor();
}
Marshal.Release(ptr);
}
}
}
}
}
private T GetService <T>(ITextBuffer textBuffer, Type serviceType)
{
var vsBuffer = adaptersFactory.GetBufferAdapter(textBuffer);
if (vsBuffer == null)
{
return(default(T));
}
Guid guidServiceProvider = VSConstants.IID_IUnknown;
IObjectWithSite objectWithSite = vsBuffer as IObjectWithSite;
IntPtr ptrServiceProvider = IntPtr.Zero;
objectWithSite.GetSite(ref guidServiceProvider, out ptrServiceProvider);
Microsoft.VisualStudio.OLE.Interop.IServiceProvider serviceProvider =
(Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Marshal.GetObjectForIUnknown(ptrServiceProvider);
Guid guidService = serviceType.GUID;
Guid guidInterface = typeof(T).GUID;
IntPtr ptrObject = IntPtr.Zero;
int hr = serviceProvider.QueryService(ref guidService, ref guidInterface, out ptrObject);
if (ErrorHandler.Failed(hr) || ptrObject == IntPtr.Zero)
{
return(default(T));
}
T result = (T)Marshal.GetObjectForIUnknown(ptrObject);
Marshal.Release(ptrObject);
return(result);
}
public int QueryService(ref Guid guidService, ref Guid riid, out IntPtr ppvObject)
{
if (_vsServiceProvider != null)
{
return(_vsServiceProvider.QueryService(ref guidService, ref riid, out ppvObject));
}
else
{
ppvObject = IntPtr.Zero;
return(VSConstants.E_NOINTERFACE);
}
}
// ------------------------------------------------------
/// <summary>
/// Gets the IVsTrackProjectDocuments2 service from Visual Studio.
/// </summary>
/// <returns>
/// The IVsTrackProjectDocuments2 interface reference.
/// </returns>
private IVsTrackProjectDocuments2 GetTrackProjectDocuments()
{
Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp =
(Microsoft.VisualStudio.OLE.Interop.IServiceProvider)
GetService(typeof(DTE));
Guid guidSP = typeof(SVsTrackProjectDocuments).GUID;
Guid guidIID = typeof(IVsTrackProjectDocuments2).GUID;
IntPtr ptrUnknown;
sp.QueryService(ref guidSP, ref guidIID, out ptrUnknown);
IVsTrackProjectDocuments2 vsTrackProjDocs =
(IVsTrackProjectDocuments2)
Marshal.GetObjectForIUnknown(ptrUnknown);
Marshal.Release(ptrUnknown);
return(vsTrackProjDocs);
}
/// <summary>Implements the Exec method of the IDTCommandTarget interface. This is called when the command is invoked.</summary>
/// <param term='commandName'>The name of the command to execute.</param>
/// <param term='executeOption'>Describes how the command should be run.</param>
/// <param term='varIn'>Parameters passed from the caller to the command handler.</param>
/// <param term='varOut'>Parameters passed from the command handler to the caller.</param>
/// <param term='handled'>Informs the caller if the command was handled or not.</param>
/// <seealso class='Exec' />
public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
handled = false;
if (executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)
{
//<Snippet2>
if (commandName == "Addin.Connect.Addin")
{
IOleServiceProvider sp = (IOleServiceProvider)
_applicationObject;
Guid SID = typeof(SVsUIShell).GUID;
Guid IID = typeof(IVsUIShell).GUID;
IntPtr output;
sp.QueryService(ref SID, ref IID, out output);
IVsUIShell uiShell = (IVsUIShell)Marshal.GetObjectForIUnknown(output);
Guid clsid = Guid.Empty;
int result;
uiShell.ShowMessageBox(
0,
ref clsid,
"MyAddin",
string.Format(
CultureInfo.CurrentCulture, "Inside " + this.ToString()),
string.Empty,
0,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_INFO,
0,
out result);
handled = true;
return;
}
//</Snippet2>
}
}
/// <summary>
/// Gets the specified service from known service provider and for given GUID.
/// </summary>
public static object GetService(Microsoft.VisualStudio.OLE.Interop.IServiceProvider serviceProvider, Guid serviceGUID)
{
object objService = null;
IntPtr objInPtr;
Guid objSIDGuid = serviceGUID;
Guid objIIDGuid = serviceGUID;
int hResult = serviceProvider.QueryService(ref objSIDGuid, ref objIIDGuid, out objInPtr);
if (hResult != 0)
{
//Marshal.ThrowExceptionForHR(hResult);
return(null);
}
if (objInPtr != IntPtr.Zero)
{
objService = Marshal.GetObjectForIUnknown(objInPtr);
Marshal.Release(objInPtr);
}
return(objService);
}
public int QueryService(ref Guid sid, ref Guid iid, out IntPtr ppvObject)
{
return(_otherServiceProvider.QueryService(ref sid, ref iid, out ppvObject));
}
/// <devdoc>
/// Retrieves the requested service. The guid must be specified; the class is only
/// used when debugging and it may be null.
/// </devdoc>
private object GetService(Guid guid, Type serviceType)
{
object service = null;
// No valid guid on the passed in class, so there is no service for it.
//
if (guid.Equals(Guid.Empty))
{
Debug.WriteLineIf(TRACESERVICE.TraceVerbose, "\tNo SID -- Guid is empty");
return(null);
}
// We provide a couple of services of our own.
//
if (defaultServices)
{
if (guid.Equals(NativeMethods.IID_IServiceProvider))
{
return(serviceProvider);
}
if (guid.Equals(NativeMethods.IID_IObjectWithSite))
{
return((IObjectWithSite)this);
}
}
IntPtr pUnk = IntPtr.Zero;
Guid guidUnk = NativeMethods.IID_IUnknown;
int hr = serviceProvider.QueryService(ref guid, ref guidUnk, out pUnk);
if ((NativeMethods.Succeeded(hr)) && (IntPtr.Zero != pUnk))
{
try {
service = Marshal.GetObjectForIUnknown(pUnk);
}
finally {
Marshal.Release(pUnk);
}
}
else
{
service = null;
// These may be interesting to log.
//
Debug.WriteLineIf(TRACESERVICE.TraceVerbose, "\tQueryService failed");
#if DEBUG
// Ensure that this service failure was not the result of a bad QI implementation.
// In C++, 99% of a service query uses SID == IID, but for us, we always use IID = IUnknown
// first. If the service didn't implement IUnknown correctly, we'll fail the service request
// and it's very difficult to track this down.
//
pUnk = IntPtr.Zero;
hr = serviceProvider.QueryService(ref guid, ref guid, out pUnk);
if ((NativeMethods.Succeeded(hr)) && (IntPtr.Zero != pUnk))
{
object obj = null;
try {
obj = Marshal.GetObjectForIUnknown(pUnk);
}
finally {
Marshal.Release(pUnk);
}
// Note that I do not return this service if we succeed -- I don't
// want to make debug work correctly when retail doesn't!
Debug.Assert(!System.Runtime.InteropServices.Marshal.IsComObject(obj),
"The service " + (serviceType != null ? serviceType.Name : guid.ToString()) +
" implements it's own interface, but does not implement IUnknown!\r\n" +
"This is a bad service implementation, not a problem in the CLR service provider mechanism." + obj.ToString());
}
#endif
}
return(service);
}