/// <summary> /// Get the currently registered managed object or creates a new managed object and registers it. /// </summary> /// <param name="impl">The <see cref="ComWrappers" /> implementation to use when creating the managed object.</param> /// <param name="externalComObject">Object to import for usage into the .NET runtime.</param> /// <param name="innerMaybe">The inner instance if aggregation is involved</param> /// <param name="flags">Flags used to describe the external object.</param> /// <param name="wrapperMaybe">The <see cref="object"/> to be used as the wrapper for the external object.</param> /// <param name="retValue">The managed object associated with the supplied external COM object or <c>null</c> if it could not be created.</param> /// <returns>Returns <c>true</c> if a managed object could be retrieved/created, <c>false</c> otherwise</returns> /// <remarks> /// If <paramref name="impl" /> is <c>null</c>, the global instance (if registered) will be used. /// </remarks> private static bool TryGetOrCreateObjectForComInstanceInternal( ComWrappers impl, IntPtr externalComObject, IntPtr innerMaybe, CreateObjectFlags flags, object?wrapperMaybe, out object?retValue ) { if (externalComObject == IntPtr.Zero) { throw new ArgumentNullException(nameof(externalComObject)); } // If the inner is supplied the Aggregation flag should be set. if (innerMaybe != IntPtr.Zero && !flags.HasFlag(CreateObjectFlags.Aggregation)) { throw new InvalidOperationException( SR.InvalidOperation_SuppliedInnerMustBeMarkedAggregation ); } object?wrapperMaybeLocal = wrapperMaybe; retValue = null; return(TryGetOrCreateObjectForComInstanceInternal( ObjectHandleOnStack.Create(ref impl), impl.id, externalComObject, innerMaybe, flags, ObjectHandleOnStack.Create(ref wrapperMaybeLocal), ObjectHandleOnStack.Create(ref retValue) )); }
protected override object CreateObject(IntPtr externalComObject, CreateObjectFlags flags) { // Assert use of the UniqueInstance flag since the returned Native Object Wrapper always // supports IDisposable and its Dispose will always release and suppress finalization. // If the wrapper doesn't always support IDisposable the assert can be relaxed. Debug.Assert(flags.HasFlag(CreateObjectFlags.UniqueInstance)); // Throw an exception if the type is not supported by the implementation. // Null can be returned as well, but an ArgumentNullException will be thrown for // the consumer of this ComWrappers instance. return(SymNgenWriterWrapper.CreateIfSupported(externalComObject) ?? throw new NotSupportedException()); }