public static T CreateFromDll <T>(string dllName, Guid mpaguid)
{
if (String.IsNullOrEmpty(dllName))
{
throw new ArgumentNullException("dllName");
}
//Get a classFactory for our classID
IClassFactory classFactory = ComHelper.GetClassFactory(dllName, mpaguid);
if (classFactory == null)
{
throw new COMException(String.Format("Can't create ClassFactory from '{0}", dllName));
}
//And create an object-instance using that class factory
Guid iGUID = typeof(T).GUID;
Object obj;
try
{
Marshal.ThrowExceptionForHR(classFactory.CreateInstance(null, ref iGUID, out obj));
return((T)obj);
}
finally { Marshal.ReleaseComObject(classFactory); }
}
private static IFilter LoadFilterFromDll(string ext, string dllName, string filterPersistClass)
{
Type T;
object obj;
Cache_V2.TryGetValue(ext, out T);
if (null == T)
{
T = Type.GetTypeFromCLSID(new Guid(filterPersistClass));
}
if (null != T)
{
Cache_V2[ext] = T;
//obj = T.InvokeMember("_ctor", BindingFlags.CreateInstance, null, null, null);
obj = Activator.CreateInstance(T);
}
else
{
IClassFactory classFactory = GetClassFactory(ext, dllName, filterPersistClass);
if (null == classFactory)
{
return(null);
}
var IFilterGUID = new Guid(Constants.IFilterGUID);
classFactory.CreateInstance(null, ref IFilterGUID, out obj);
}
//var mixedFilter = Marshal.GetTypedObjectForIUnknown(ptr, typeof(MixedIFilterClass)) as MixedIFilterClass;
var mixedFilter = (MixedIFilterClass)Marshal.CreateWrapperOfType(obj, typeof(MixedIFilterClass));
mixedFilter.InternalObj = obj;
return((IFilter)mixedFilter);
}
protected override void Initialize(IGraphBuilder pGraphBuilder, IntPtr hMediaWindow)
{
object factoryObject = null;
object presenterObject = null;
try
{
int hr = ClassFactory.GetEvrPresenterClassFactory(ref CLSID_CustomEVRPresenter, ref ClassFactory.IID_ClassFactory, out factoryObject);
Marshal.ThrowExceptionForHR(hr);
IClassFactory factory = (IClassFactory)factoryObject;
var iidPresenter = typeof(IMFVideoPresenter).GUID;
hr = factory.CreateInstance(null, ref iidPresenter, out presenterObject);
Marshal.ThrowExceptionForHR(hr);
IMFVideoPresenter presenter = (IMFVideoPresenter)presenterObject;
IMFVideoRenderer renderer = (IMFVideoRenderer)BaseFilter; // will be released when IBaseFilter is released
renderer.InitializeRenderer(null, presenter);
IMFGetService pMFGetService = (IMFGetService)BaseFilter; // will be released when IBaseFilter is released
object o;
var serviceId = ServiceID.EnhancedVideoRenderer;
var iidImfVideoDisplayControl = typeof(IMFVideoDisplayControl).GUID;
Marshal.ThrowExceptionForHR(pMFGetService.GetService(ref serviceId, ref iidImfVideoDisplayControl, out o));
_pMFVideoDisplayControl = (IMFVideoDisplayControl)o;
_pMFVideoDisplayControl.SetVideoWindow(hMediaWindow);
_pMFVideoDisplayControl.SetAspectRatioMode(MFVideoAspectRatioMode.MFVideoARMode_None);
_pvpPresenterConfig = (IPvpPresenterConfig)presenterObject;
_pvpPresenterConfig.SetBufferCount(PRESENTER_BUFFER_COUNT);
_pvpPresenterHook.HookUp(presenterObject);
// as EVR requests IMFVideoDisplayControl from the presenter and our custom presenter implements IPvpPresenter and IPvpPresenterConfig
// presenterObject and _pMFVideoDisplayControl point to the same RCW
presenterObject = null; // we will release the presenter when releasing _pMFVideoDisplayControl
}
catch
{
_pMFVideoDisplayControl = null;
_pvpPresenterConfig = null;
}
finally
{
if (factoryObject != null)
{
Marshal.FinalReleaseComObject(factoryObject);
}
if (presenterObject != null)
{
Marshal.FinalReleaseComObject(presenterObject);
}
}
}
private object GetClassInstance(Guid classguid, Guid interfguid, Guid classfactoryguid, Guid classfactory2guid)
{
object classinstance = null;
// create instance via raw dll functions
// ensures we get the real vtable
try
{
if (classinstance == null)
{
// Single do..while loop - to support "break;"
do
{
Microsoft.Win32.RegistryKey rk = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey("CLSID\\{" + classguid.ToString() + "}\\InprocServer32");
if (rk == null)
{
break;
}
string classdllname = rk.GetValue(null).ToString();
IntPtr libH = KERNEL32.LoadLibrary(classdllname);
if (libH == IntPtr.Zero)
{
break;
}
IntPtr factoryFunc = KERNEL32.GetProcAddress(libH, "DllGetClassObject");
if (factoryFunc == IntPtr.Zero)
{
break;
}
DllGetClassObjectDelegate factoryDel = (DllGetClassObjectDelegate)Marshal.GetDelegateForFunctionPointer(factoryFunc, typeof(DllGetClassObjectDelegate));
object classfactoryO;
// Try with IClassFactory first
factoryDel(ref classguid, ref classfactoryguid, out classfactoryO);
if (classfactoryO != null)
{
IClassFactory classfactory = (IClassFactory)classfactoryO;
classfactory.CreateInstance(null, ref interfguid, out classinstance);
Marshal.FinalReleaseComObject(classfactory);
}
else
{
// Now try with IClassFactory2
factoryDel(ref classguid, ref classfactory2guid, out classfactoryO);
if (classfactoryO == null)
{
break;
}
IClassFactory2 classfactory = (IClassFactory2)classfactoryO;
classinstance = classfactory.CreateInstance(null, interfguid);
Marshal.FinalReleaseComObject(classfactory);
}
} while (false);
}
}
catch { }
return(classinstance);
}
private static void CoCreateFromMsdia(Guid clsidOfServer, Guid riid, out IntPtr pvObject)
{
IntPtr pClassFactory = IntPtr.Zero;
int hr = DllGetClassObject(clsidOfServer, new Guid("00000001-0000-0000-C000-000000000046"), out pClassFactory);
IClassFactory classFactory = Marshal.GetObjectForIUnknown(pClassFactory) as IClassFactory;
classFactory.CreateInstance(IntPtr.Zero, ref riid, out pvObject);
Marshal.Release(pClassFactory);
Marshal.ReleaseComObject(classFactory);
}
/// <summary>
/// Creates an object from a given COM dll by a class id and a given interface
/// </summary>
public static bool LoadAndCreate <T>(string dllPath, out T source, out string errorMessage, Guid classId)
where T : class
{
if (string.IsNullOrWhiteSpace(dllPath) && !System.IO.File.Exists(dllPath))
{
source = null;
errorMessage = "Path to a dll not found - " + dllPath;
return(false);
}
IntPtr dllHandle = LoadLibrary(dllPath);
if (dllHandle == IntPtr.Zero)
{
source = null;
errorMessage = "Could not load library " + dllPath;
return(false);
}
try
{
IntPtr fp = GetProcAddress(dllHandle, "DllGetClassObject");
DllGetClassObjectFunction getClassObj = (DllGetClassObjectFunction)Marshal.GetDelegateForFunctionPointer(fp, typeof(DllGetClassObjectFunction));
object c;
Guid diaSourceClassGuid = classId;
Guid classFactoryGuid = typeof(IClassFactory).GUID;
int hr = getClassObj(ref diaSourceClassGuid, ref classFactoryGuid, out c);
if (hr != 0)
{
throw new COMException("Could not get object for CLSID " + classId, hr);
}
IClassFactory factory = c as IClassFactory;
T diaSource = (T)factory.CreateInstance(null, typeof(T).GUID);
// the cast to T increased the reference count
//int cnt = Marshal.ReleaseComObject(diaSource);
//if (cnt != 1)
// Console.WriteLine("diaSource.RefCount not 1, but {0}", cnt);
source = diaSource;
errorMessage = "";
return(true);
}
catch (Exception e)
{
errorMessage = string.Format("Could not get {0} from the library {1}. Details: {2}", typeof(T).Name, dllPath, e);
source = null;
return(false);
}
}
public static IDiaDataSource CreateInstance()
{
if (DiaSourceFactory == null)
{
var DiaSourceClassGuid = new Guid("e6756135-1e65-4d17-8576-610761398c3c");
var IID_IClassFactory = typeof(IClassFactory).GUID;
DiaSourceFactory = (IClassFactory)DllGetClassObject(ref DiaSourceClassGuid, ref IID_IClassFactory);
}
var IID_IDiaDataSource = typeof(IDiaDataSource).GUID;
return((IDiaDataSource)DiaSourceFactory.CreateInstance(null, IID_IDiaDataSource));
}
public static T CreateInstance <T>(IClassFactory classFactory, Type interfaceType) where T : class
{
object obj;
var wbGuid = interfaceType.GUID;
classFactory.CreateInstance(null, ref wbGuid, out obj);
var res = obj as T;
if (res == null)
{
throw new Exception("res == null");
}
return(res);
}
public static object CreatePassword()
{
object classObject;
DllGetClassObject(ref ProgID_IPassword, ref IID_IClassFactory, out classObject);
uint dwRegister;
CoRegisterClassObject(ref IID_IClassFactory, classObject, 0, 0, out dwRegister);
IClassFactory classFactory = classObject as IClassFactory;
object password = classFactory.CreateInstance(null, ref IID_IUnknown);
return(password);
}
private static object CreateInstanceFromFileInternal(string filePath, Guid classId, Guid iid)
{
IntPtr hModule, getClassObjectPtr, classFactoryPtr = IntPtr.Zero;
IClassFactory classFactory = null;
try
{
hModule = NativeMethods.LoadLibrary(filePath);
if (hModule == IntPtr.Zero)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
getClassObjectPtr = NativeMethods.GetProcAddress(hModule, "DllGetClassObject");
if (getClassObjectPtr == IntPtr.Zero)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
DllGetClassObjectSig DllGetClassObject = (DllGetClassObjectSig)Marshal.GetDelegateForFunctionPointer(getClassObjectPtr, typeof(DllGetClassObjectSig));
HResult hr = DllGetClassObject(classId, typeof(IClassFactory).GUID, out classFactoryPtr);
hr.ThrowExceptionOnError();
classFactory = (IClassFactory)Marshal.GetObjectForIUnknown(classFactoryPtr);
object result;
hr = classFactory.CreateInstance(null, iid, out result);
hr.ThrowExceptionOnError();
return(result);
}
finally
{
if (classFactory != null)
{
int i = Marshal.ReleaseComObject(classFactory);
classFactory = null;
}
if (classFactoryPtr != IntPtr.Zero)
{
int i = Marshal.Release(classFactoryPtr);
classFactoryPtr = IntPtr.Zero;
}
}
}
private static IFilter LoadFilterFromDll(string dllName, string filterPersistClass)
{
IClassFactory classFactory = ComHelper.GetClassFactory(dllName, filterPersistClass);
if (classFactory == null)
{
return(null);
}
Guid IFilterGUID = new Guid("89BCB740-6119-101A-BCB7-00DD010655AF");
Object obj;
classFactory.CreateInstance(null, ref IFilterGUID, out obj);
return(obj as IFilter);
}
private static IFilter LoadFilterFromDll(string dllName, string filterPersistClass)
{
//Get a classFactory for our classID
IClassFactory classFactory = ComHelper.GetClassFactory(dllName, filterPersistClass);
if (classFactory == null)
{
return(null);
}
//And create an IFilter instance using that class factory
Object obj;
classFactory.CreateInstance(null, ref IFilterGUID, out obj);
return(obj as IFilter);
}
private static DocHelper.IFilter LoadFilterFromDll(string dllName, string filterPersistClass)
{
//Get a classFactory for our classID
IClassFactory classFactory = ComHelper.GetClassFactory(dllName, filterPersistClass);
if (classFactory == null)
{
return(null);
}
//And create an DocHelper.IFilter instance using that class factory
Guid IFilterGUID = new Guid("89BCB740-6119-101A-BCB7-00DD010655AF");
Object obj;
classFactory.CreateInstance(null, ref IFilterGUID, out obj);
return(obj as DocHelper.IFilter);
}
/// <summary>
/// Load a COM object from the supplied assembly using the supplied class ID and interface ID.
/// </summary>
/// <param name="pathToNativeAssembly">Path to assembly</param>
/// <param name="clsid">Class ID</param>
/// <param name="iid">Interface ID</param>
/// <returns>Loaded COM instance</returns>
public static object CreateInstanceFrom(
string pathToNativeAssembly,
Guid clsid,
Guid iid)
{
if (string.IsNullOrEmpty(pathToNativeAssembly))
{
throw new ArgumentNullException(nameof(pathToNativeAssembly));
}
IntPtr nativeDllPointer = NativeMethods.LoadLibraryEx(
pathToNativeAssembly,
IntPtr.Zero,
NativeMethods.LoadLibraryFlags.LOAD_WITH_ALTERED_SEARCH_PATH);
if (nativeDllPointer == IntPtr.Zero)
{
throw new DllNotFoundException(pathToNativeAssembly);
}
IntPtr dllGetClassObjectFunctionPointer = NativeMethods.GetProcAddress(nativeDllPointer, "DllGetClassObject");
if (dllGetClassObjectFunctionPointer == IntPtr.Zero)
{
throw new NullReferenceException("DllGetClassObject");
}
#pragma warning disable 618
DllGetClassObjectDelegate dllGetClassObject = (DllGetClassObjectDelegate)Marshal.GetDelegateForFunctionPointer(
#pragma warning restore 618
dllGetClassObjectFunctionPointer,
typeof(DllGetClassObjectDelegate));
object ppv = null;
object instance = null;
dllGetClassObject(clsid, typeof(IClassFactory).GetTypeInfo().GUID, out ppv);
IClassFactory factory = ppv as IClassFactory;
if (factory != null)
{
instance = factory.CreateInstance(null, iid);
Marshal.ReleaseComObject(factory);
}
return(instance);
}
/// <summary>
/// Loads an COM .dll and creates an instance of the given Interface with IID <paramref name="interfaceId"/>.
/// </summary>
/// <param name="dllName">Filename of a .dll or .ax component</param>
/// <param name="interfaceId">Interface to create an object instance for</param>
/// <param name="useAssemblyRelativeLocation">Combine the given file name to a full path</param>
/// <returns>Instance or <c>null</c></returns>
public static IBaseFilter LoadFilterFromDll(string dllName, Guid interfaceId, bool useAssemblyRelativeLocation = false)
{
// Get a ClassFactory for our classID
string dllPath = useAssemblyRelativeLocation ? BuildAssemblyRelativePath(dllName) : dllName;
IClassFactory classFactory = ComHelper.GetClassFactory(dllPath, interfaceId);
if (classFactory == null)
{
return(null);
}
// And create an IFilter instance using that class factory
Guid baseFilterGuid = typeof(IBaseFilter).GUID;
object obj;
classFactory.CreateInstance(null, ref baseFilterGuid, out obj);
return(obj as IBaseFilter);
}
private void btnCreate_Click(object sender, EventArgs e)
{
try
{
IClassFactory factory = (IClassFactory)m_pObject;
object new_object;
Guid IID_IUnknown = COMInterfaceEntry.IID_IUnknown;
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Name", m_objName);
factory.CreateInstance(null, ref IID_IUnknown, out new_object);
ObjectInformation view = new ObjectInformation(m_registry, m_objName, new_object,
props, m_registry.GetInterfacesForObject(new_object));
Program.GetMainForm().HostControl(view);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private static IFilter LoadFilterFromDll(string dllName, string filterPersistClass)
{
//Get a classFactory for our classID
IClassFactory classFactory = ComHelper.GetClassFactory(dllName, filterPersistClass);
if (classFactory == null)
{
return(null);
}
//And create an IFilter instance using that class factory
// http://msdn2.microsoft.com/en-us/library/aa965717.aspx
// The first identifies all filters' persistent handler, IID_IFilter, which is {89BCB740-6119-101A-BCB7-00DD010655AF}. This CLSID is constant for all filters that implement IFilter.
Guid IFilterGUID = new Guid("89BCB740-6119-101A-BCB7-00DD010655AF");
Object obj;
classFactory.CreateInstance(null, ref IFilterGUID, out obj);
return(obj as IFilter);
}
/// <summary>
/// Create a new EVR video presenter
/// </summary>
/// <returns></returns>
public static EvrPresenter CreateNew(IMFActivate activate)
{
object comObject = null;
int hr = 0;
/* Our exception var we use to hold the exception
* until we need to throw it (after clean up) */
Exception exception = null;
/* A COM object we query form our native library */
IClassFactory factory = null;
/* Create our 'helper' class */
var evrPresenter = new EvrPresenter();
/* Call the DLL export to create the class factory */
if (ProcessBits == 32)
{
//activate.SetGUID(MFAttributesClsid.MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, EVR_PRESENTER_CLSID);
hr = DllGetClassObject32(EVR_PRESENTER_CLSID, IUNKNOWN_GUID, out comObject);
//activate.SetUnknown(MFAttributesClsid.MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE, evrPresenter as IMFActivate);
//activate.ActivateObject(EVR_PRESENTER_CLSID, out comObject);
}
else if (ProcessBits == 64)
{
activate.SetGUID(MFAttributesClsid.MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, EVR_PRESENTER_CLSID);
hr = DllGetClassObject64(EVR_PRESENTER_CLSID, IUNKNOWN_GUID, out comObject);
}
else
{
exception = new Exception(string.Format("{0} bit processes are unsupported", ProcessBits));
goto bottom;
}
/* Check if our call to our DLL failed */
if (hr != 0 || comObject == null)
{
exception = new COMException("Could not create a new class factory.", hr);
goto bottom;
}
/* Cast the COM object that was returned to a COM interface type */
factory = comObject as IClassFactory;
if (factory == null)
{
exception = new Exception("Could not QueryInterface for the IClassFactory interface");
goto bottom;
}
/* Get the GUID of the IMFVideoPresenter */
Guid guidActivate = typeof(IMFActivate).GUID;
object comActObject;
/* Creates a new instance of the IMFVideoPresenter */
factory.CreateInstance(null, ref guidActivate, out comActObject);
// Set the Unknown IMFAttribute to ActivateObject
activate.SetUnknown(MFAttributesClsid.MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE, comActObject);
/* QueryInterface for the IMFVideoPresenter */
var presenter = comActObject as IMFVideoPresenter;
/* QueryInterface for our callback registration interface */
var registerCb = comActObject as IEVRPresenterRegisterCallback;
if (registerCb == null)
{
exception = new Exception("Could not QueryInterface for IEVRPresenterRegisterCallback");
goto bottom;
}
/* Register the callback to the 'helper' class we created */
registerCb.RegisterCallback(evrPresenter);
/* Populate the IMFVideoPresenter */
evrPresenter.VideoPresenter = presenter;
bottom:
if (factory != null)
{
Marshal.FinalReleaseComObject(factory);
}
if (exception != null)
{
throw exception;
}
return(evrPresenter);
}
/// <summary>
/// Create a new EVR video presenter
/// </summary>
/// <returns></returns>
public static WindowShadow CreateNew()
{
object comObject;
int hr;
/* Our exception var we use to hold the exception
* until we need to throw it (after clean up) */
Exception exception = null;
/* A COM object we query form our native library */
IClassFactory factory = null;
/* Create our 'helper' class */
var windowShadow = new WindowShadow();
/* Call the DLL export to create the class factory */
if (ProcessBits == 32)
{
hr = DllGetClassObject32(WINDOW_SHADOW_CLSID, IUNKNOWN_GUID, out comObject);
}
else if (ProcessBits == 64)
{
hr = DllGetClassObject64(WINDOW_SHADOW_CLSID, IUNKNOWN_GUID, out comObject);
}
else
{
exception = new Exception(string.Format("{0} bit processes are unsupported", ProcessBits));
goto bottom;
}
/* Check if our call to our DLL failed */
if (hr != 0 || comObject == null)
{
exception = new COMException("Could not create a new class factory.", hr);
goto bottom;
}
/* Cast the COM object that was returned to a COM interface type */
factory = comObject as IClassFactory;
if (factory == null)
{
exception = new Exception("Could not QueryInterface for the IClassFactory interface");
goto bottom;
}
/* Get the GUID of the class */
Guid guid = typeof(IWindowShadow).GUID;
/* Creates a new instance of the IMFVideoPresenter */
factory.CreateInstance(null, ref guid, out comObject);
/* QueryInterface for the IMFVideoPresenter */
var shadower = comObject as IWindowShadow;
/* Populate the shadower */
windowShadow.Shadower = shadower;
bottom:
if (factory != null)
{
Marshal.FinalReleaseComObject(factory);
}
if (exception != null)
{
throw exception;
}
return(windowShadow);
}
/// <summary>
/// Load the merge object directly from a local mergemod.dll without going through COM registration.
/// </summary>
/// <returns>Merge interface.</returns>
internal static IMsmMerge2 GetMsmMerge()
{
IClassFactory classFactory = (IClassFactory)MergeModGetClassObject(typeof(MsmMerge2).GUID, typeof(IClassFactory).GUID);
return((IMsmMerge2)classFactory.CreateInstance(IntPtr.Zero, typeof(IMsmMerge2).GUID));
}
public static unsafe void Query(ComClassInfo cci)
{
Guid classguid = cci.ClassType.GUID;
Guid interfguid = cci.InterfaceType.GUID;
Guid classfactoryguid = typeof(IClassFactory).GUID;
Guid classfactory2guid = typeof(IClassFactory2).GUID;
object classinstance = null;
#if false
// create an instance via .NET built-in functionality
// vtable might be hijacked by rpcrt4.dll
classinstance = cci.ClassType.InvokeMember("", BindingFlags.CreateInstance, null, null, null);
#endif
#if false
// create via ole-convenience-function
// vtable might be hijacked by rpcrt4.dll
OLE32.CoCreateInstance(ref classguid, null, 1 + 4, ref interfguid, out classinstance);
#endif
#if false
// create via ole-functions
// vtable might be hijacked by rpcrt4.dll
try
{
if (classinstance == null)
{
object classfactoryO;
OLE32.CoGetClassObject(ref classguid, 1 + 4, 0, ref classfactoryguid, out classfactoryO);
IClassFactory classfactory = (IClassFactory)classfactoryO;
classfactory.CreateInstance(null, ref interfguid, out classinstance);
Marshal.FinalReleaseComObject(classfactory);
}
}
catch { }
try
{
if (classinstance == null)
{
object classfactoryO;
OLE32.CoGetClassObject(ref classguid, 1 + 4, 0, ref classfactoryguid, out classfactoryO);
IClassFactory2 classfactory = (IClassFactory2)classfactoryO;
classinstance = classfactory.CreateInstance(null, interfguid);
Marshal.FinalReleaseComObject(classfactory);
}
}
catch { }
if (classinstance == null)
{
// Error...
}
#endif
#if true
// create via raw dll functions
// no chance for other people to hijack the vtable
try
{
do
{
RegistryKey rk = Registry.ClassesRoot.OpenSubKey("CLSID\\{" + classguid + "}\\InprocServer32");
if (rk == null)
{
break;
}
string classdllname = rk.GetValue(null).ToString();
IntPtr libH = KERNEL32.LoadLibrary(classdllname);
if (libH == IntPtr.Zero)
{
break;
}
IntPtr factoryFunc = KERNEL32.GetProcAddress(libH, "DllGetClassObject");
if (factoryFunc == IntPtr.Zero)
{
break;
}
var factoryDel =
(DllGetClassObjectDelegate)
Marshal.GetDelegateForFunctionPointer(factoryFunc, typeof(DllGetClassObjectDelegate));
object classfactoryO;
factoryDel(ref classguid, ref classfactoryguid, out classfactoryO);
if (classfactoryO == null)
{
break;
}
var classfactory = (IClassFactory)classfactoryO;
classfactory.CreateInstance(null, ref interfguid, out classinstance);
Marshal.FinalReleaseComObject(classfactory);
} while (false);
}
catch
{
}
try
{
if (classinstance == null)
{
do
{
RegistryKey rk = Registry.ClassesRoot.OpenSubKey("CLSID\\{" + classguid + "}\\InprocServer32");
if (rk == null)
{
break;
}
string classdllname = rk.GetValue(null).ToString();
IntPtr libH = KERNEL32.LoadLibrary(classdllname);
if (libH == IntPtr.Zero)
{
break;
}
IntPtr factoryFunc = KERNEL32.GetProcAddress(libH, "DllGetClassObject");
if (factoryFunc == IntPtr.Zero)
{
break;
}
var factoryDel =
(DllGetClassObjectDelegate)
Marshal.GetDelegateForFunctionPointer(factoryFunc, typeof(DllGetClassObjectDelegate));
object classfactoryO;
factoryDel(ref classguid, ref classfactory2guid, out classfactoryO);
if (classfactoryO == null)
{
break;
}
var classfactory = (IClassFactory2)classfactoryO;
classinstance = classfactory.CreateInstance(null, interfguid);
Marshal.FinalReleaseComObject(classfactory);
} while (false);
}
}
catch
{
}
if (classinstance == null)
{
// Error...
}
#endif
IntPtr interfaceIntPtr = Marshal.GetComInterfaceForObject(classinstance, cci.InterfaceType);
var interfaceRawPtr = (int ***)interfaceIntPtr.ToPointer();
// get vtable
int **vTable = *interfaceRawPtr;
// get com-slot-number (vtable-index) of function X
// get function-address from vtable
int mi_vto = Marshal.GetComSlotForMethodInfo(cci.Method);
int *faddr = vTable[mi_vto];
cci.MFunctionPointer = new IntPtr(faddr);
// release intptr
Marshal.Release(interfaceIntPtr);
Marshal.FinalReleaseComObject(classinstance);
}
internal IProxyProvider GetProxyProvider()
{
if (null == monikerSupportLibrary)
{
lock (this)
{
if (null == monikerSupportLibrary)
{
getCODelegate = null;
using (RegistryHandle regKey = RegistryHandle.GetCorrectBitnessHKLMSubkey((IntPtr.Size == 8), ServiceModelInstallStrings.WinFXRegistryKey))
{
string file = regKey.GetStringValue(ServiceModelInstallStrings.RuntimeInstallPathName).TrimEnd('\0') + "\\" + fileName;
SafeLibraryHandle tempLibrary = UnsafeNativeMethods.LoadLibrary(file);
tempLibrary.DoNotFreeLibraryOnRelease();
monikerSupportLibrary = tempLibrary;
if (monikerSupportLibrary.IsInvalid)
{
monikerSupportLibrary.SetHandleAsInvalid();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ServiceMonikerSupportLoadFailed(file));
}
}
}
}
}
if (null == getCODelegate)
{
lock (this)
{
if (null == getCODelegate)
{
try
{
IntPtr procaddr = UnsafeNativeMethods.GetProcAddress(monikerSupportLibrary, functionName);
getCODelegate = (DelegateDllGetClassObject)Marshal.GetDelegateForFunctionPointer(procaddr, typeof(DelegateDllGetClassObject));
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ComPlusProxyProviderException(SR.GetString(SR.FailedProxyProviderCreation), e));
}
}
}
}
IClassFactory cf = null;
IProxyProvider proxyProvider = null;
try
{
getCODelegate(ClsidProxyInstanceProvider, typeof(IClassFactory).GUID, ref cf);
proxyProvider = cf.CreateInstance(null, typeof(IProxyProvider).GUID) as IProxyProvider;
Thread.MemoryBarrier();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ComPlusProxyProviderException(SR.GetString(SR.FailedProxyProviderCreation), e));
}
finally
{
if (null != cf)
{
Marshal.ReleaseComObject(cf);
cf = null;
}
}
return(proxyProvider);
}
public static object IldbCoCreateInstance(System.Guid clsid, System.Guid iid)
{
IClassFactory fac = (IClassFactory)DllGetClassObject(clsid, typeof(IClassFactory).GUID);
return(fac.CreateInstance(null, iid));
}
internal IProxyProvider GetProxyProvider()
{
if (this.monikerSupportLibrary == null)
{
lock (this)
{
if (this.monikerSupportLibrary == null)
{
this.getCODelegate = null;
using (RegistryHandle handle = RegistryHandle.GetCorrectBitnessHKLMSubkey(IntPtr.Size == 8, @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Client"))
{
string libFilename = handle.GetStringValue("InstallPath").TrimEnd(new char[1]) + @"\ServiceMonikerSupport.dll";
this.monikerSupportLibrary = UnsafeNativeMethods.LoadLibrary(libFilename);
this.monikerSupportLibrary.DoNotFreeLibraryOnRelease();
if (this.monikerSupportLibrary.IsInvalid)
{
this.monikerSupportLibrary.SetHandleAsInvalid();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ServiceMonikerSupportLoadFailed(libFilename));
}
}
}
}
}
if (this.getCODelegate == null)
{
lock (this)
{
if (this.getCODelegate == null)
{
try
{
IntPtr procAddress = UnsafeNativeMethods.GetProcAddress(this.monikerSupportLibrary, "DllGetClassObject");
this.getCODelegate = (DelegateDllGetClassObject)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(DelegateDllGetClassObject));
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ComPlusProxyProviderException(System.ServiceModel.SR.GetString("FailedProxyProviderCreation"), exception));
}
}
}
}
IClassFactory ppv = null;
IProxyProvider provider = null;
try
{
this.getCODelegate(ClsidProxyInstanceProvider, typeof(IClassFactory).GUID, ref ppv);
provider = ppv.CreateInstance(null, typeof(IProxyProvider).GUID) as IProxyProvider;
Thread.MemoryBarrier();
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ComPlusProxyProviderException(System.ServiceModel.SR.GetString("FailedProxyProviderCreation"), exception2));
}
finally
{
if (ppv != null)
{
Marshal.ReleaseComObject(ppv);
ppv = null;
}
}
return(provider);
}
//http://www.gdcl.co.uk/2011/June/UnregisteredFilters.htm
public object CreateObjectFromPath(string dllPath, Guid clsid, bool setSearchPath, bool comFallback)
{
object createdObject = null;
IntPtr lib = IntPtr.Zero;
string fullDllPath = Path.Combine(SearchPath, dllPath);
_logger.Debug("CreateObjectFromPath: {0} - {1} - {2} - {3}", fullDllPath, clsid, setSearchPath, comFallback);
if (File.Exists(fullDllPath) && (_preferURObjects || !comFallback))
{
FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(fullDllPath);
_logger.Debug("Load: {0} Version: {1}", fileVersionInfo.FileDescription, fileVersionInfo.FileVersion);
if (_libsLoaded.ContainsKey(dllPath))
{
_logger.Debug("Load: {0} from cache", dllPath);
lib = _libsLoaded[dllPath];
}
else
{
//some dlls have external dependancies, setting the search path to its location should assist with this
if (setSearchPath)
{
NativeMethods.SetDllDirectory(Path.GetDirectoryName(fullDllPath));
}
lib = NativeMethods.LoadLibrary(fullDllPath);
if (setSearchPath)
{
NativeMethods.SetDllDirectory(null);
}
}
if (lib != IntPtr.Zero)
{
//we need to cache the handle so the COM object will work and we can clean up later
_libsLoaded[dllPath] = lib;
IntPtr fnP = NativeMethods.GetProcAddress(lib, "DllGetClassObject");
if (fnP != IntPtr.Zero)
{
DllGETCLASSOBJECTInvoker fn = Marshal.GetDelegateForFunctionPointer(fnP, typeof(DllGETCLASSOBJECTInvoker)) as DllGETCLASSOBJECTInvoker;
object pUnk = null;
int hr = fn(clsid, IID_IUnknown, out pUnk);
if (hr >= 0)
{
IClassFactory pCF = pUnk as IClassFactory;
if (pCF != null)
{
hr = pCF.CreateInstance(null, IID_IUnknown, out createdObject);
_logger.Debug("CreateInstance {0}: {1}", fileVersionInfo.FileDescription, hr);
}
}
}
else
{
_logger.Debug("Couldn't load {0}", fileVersionInfo.FileDescription);
throw new Win32Exception();
}
}
else if (comFallback)
{
_logger.Debug("No lib, load from Global COM {0}", clsid);
Type type = Type.GetTypeFromCLSID(clsid);
return(Activator.CreateInstance(type));
}
else
{
throw new Win32Exception();
}
}
else if (comFallback)
{
_logger.Debug("Load from Global COM {0}", clsid);
Type type = Type.GetTypeFromCLSID(clsid);
return(Activator.CreateInstance(type));
}
_logger.Debug("Got Object {0} from {1}", createdObject, clsid);
return(createdObject);
}
