public static void SafeDispose(this IDisposable disposable, IJobLogger logger = null)
{
try
{
if (disposable == null)
{
return;
}
if (logger?.IsEnabled(JobLogLevel.Debug) ?? false)
{
logger.LogDebug($"Disposing {disposable.GetType()}");
}
disposable.Dispose();
if (logger?.IsEnabled(JobLogLevel.Debug) ?? false)
{
logger.LogDebug($"Disposed {disposable.GetType()}");
}
}
catch (Exception ex)
{
logger?.LogError(ex, "Disposal error");
}
}
/// <summary>
/// 批量数据写入
/// </summary>
/// <param name="targetTable">目标表</param>
/// <param name="sourceData">源表</param>
/// <param name="trans">事务</param>
public int BulkCopyLocalTransaction(string targetTable, DataTable sourceData)
{
int rows = 0;
IDisposable _bulkCopyObj = null;
try
{
if (sourceData.Rows.Count == 0)
{
return(0);
}
_bulkCopyObj = _dataSource.DbProvider.CreateBulkCopyObj(_connection);
_bulkCopyObj.GetType().GetProperty("DestinationTableName").SetValue(_bulkCopyObj, targetTable, null);
_bulkCopyObj.GetType().InvokeMember("WriteToServer", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod
, null, _bulkCopyObj, new object[] { sourceData });
_bulkCopyObj.Dispose();
rows = sourceData.Rows.Count;
}
catch (Exception e)
{
if (_bulkCopyObj != null)
{
_bulkCopyObj.Dispose();
}
System.Diagnostics.Trace.WriteLine(e.Message);
}
return(rows);
}
/// <summary>
/// 批量数据写入
/// </summary>
/// <param name="targetTable">源表</param>
/// <param name="sourceData"><目标表/param>
/// <param name="trans">事务</param>
/// <returns>返回影响行数</returns>
public override int BulkCopyLocalTransaction(string targetTable, DataTable sourceData)
{
int rows = 0;
try
{
if (sourceData.Rows.Count == 0)
{
return(0);
}
using (IDisposable ifxBulkCopyObj = _dataSource.DbProvider.CreateBulkCopyObj(_connection))
{
ifxBulkCopyObj.GetType().GetProperty("DestinationTableName").SetValue(ifxBulkCopyObj, targetTable, null);
ifxBulkCopyObj.GetType().InvokeMember("WriteToServer", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod
, null, ifxBulkCopyObj, new object[] { sourceData });
rows = sourceData.Rows.Count;
}
}
catch
{
throw;
}
return(rows);
}
static void SafeDispose(IDisposable handle)
{
try
{
Logger.Info("Disposing {}", handle.GetType());
handle.Dispose();
}
catch (Exception ex)
{
Logger.Warn("{} dispose error {}", handle.GetType(), ex);
}
}
public void Dispose()
{
try
{
_trace("Disposable of type {0} is disposing".Fmt(_disposable.GetType()));
_disposable.Dispose();
_trace("Disposable of type {0} is disposed".Fmt(_disposable.GetType()));
}
catch (Exception)
{
_trace("Disposable of type {0} disposing failed".Fmt(_disposable.GetType()));
throw;
}
}
public KinectFrame(IDisposable frame)
{
if (frame == null)
{
throw new NullReferenceException();
}
if (!_supportedFrames.Contains(frame.GetType()))
{
throw new NotSupportedException(frame.GetType() + " is not a supported frame type");
}
_thisFrame = frame;
}
public static void ThrowIfDisposed(IDisposable obj)
{
if (obj.IsDisposed)
{
throw new ObjectDisposedException(obj.GetType().FullName);
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
TryCloseForm();
if (listBox1.SelectedItem == null)
{
return;
}
Assembly demo = Assembly.Load(listBox1.SelectedItem.ToString());
Type[] types = demo.GetExportedTypes();
foreach (Type type in types)
{
if (type.BaseType.Name.Equals("Game"))
{
game = (IDisposable)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
bool librariesOk = (bool)type.InvokeMember("TestLibraries", BindingFlags.InvokeMethod, null, game, null);
if (librariesOk == false)
{
return;
}
new Thread(DemoThread).Start();
while (form == null)
{
form = (Form)game.GetType().InvokeMember("Form", BindingFlags.GetProperty, null, game, null);
}
form.HandleCreated += new EventHandler(form_HandleCreated);
break;
}
}
}
public static void DisposeFields(this IDisposable obj)
{
if (Validate.TryValidateNull(obj))
{
return;
}
var list = obj.GetType().GetRuntimeFields().Where(p => p.IsStatic == false).ToList();
if (list.DoesNotHaveItems())
{
return;
}
for (var fieldCount = 0; fieldCount < list.FastCount(); fieldCount++)
{
var value = list[fieldCount].GetValue(obj);
if (value is not null)
{
if (value is IDisposable disposableItem)
{
disposableItem.TryDispose();
}
else if (value is IEnumerable collection)
{
collection.DisposeCollection();
}
}
}
}
internal static void ThrowIfDisposed(this IDisposable obj, bool disposed)
{
if (disposed)
{
throw new ObjectDisposedException(obj.GetType().Name);
}
}
/// <summary>
/// Track any IDisposable's to dispose of at the end of the request in IAppHost.OnEndRequest()
/// </summary>
/// <param name="instance"></param>
public void TrackDisposable(IDisposable instance)
{
if (instance == null)
{
return;
}
//CService is already disposed right after it has been executed
if (ServiceUtils.IsCSerivce(instance.GetType()))
{
return;
}
DispsableTracker dispsableTracker = null;
if (!Items.Contains(DispsableTracker.HashId))
{
Items[DispsableTracker.HashId] = dispsableTracker = new DispsableTracker();
}
if (dispsableTracker == null)
{
dispsableTracker = (DispsableTracker)Items[DispsableTracker.HashId];
}
dispsableTracker.Add(instance);
}
/// <summary>
/// Disposes the fields.
/// </summary>
/// <param name="obj">The object.</param>
/// <exception cref="ArgumentNullException">obj</exception>
public static void DisposeFields(this IDisposable obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj), $"{nameof(obj)} is null.");
}
var list = obj.GetType().GetRuntimeFields().Where(p => p.IsStatic == false).ToList();
for (int fieldCount = 0; fieldCount < list.Count; fieldCount++)
{
var value = list[fieldCount].GetValue(obj);
if (value != null)
{
if (value is IDisposable disposableItem)
{
disposableItem.TryDispose();
}
else if (value is IEnumerable collection)
{
collection.DisposeCollection();
}
}
}
}
public DeterministicFinalizer(IDisposable comObject)
{
var unknown = Marshal.GetIUnknownForObject(comObject);
//TODO: GetIDispatchForObject if any interfaces are ComInterfaceType InterfaceIsDual or InterfaceIsIDispatch.
var interfacePointers = comObject.GetType()
.GetInterfaces()
.Where(Marshal.IsTypeVisibleFromCom)
.Select(@interface => Marshal.GetComInterfaceForObject(comObject, @interface))
.ToList();
var supportErrorInfo = wrappers.Wrap(unknown, new Guid("df0b3d60-548f-101b-8e65-08002b2bd119"), 4);
var provideClassInfo = wrappers.Wrap(unknown, new Guid("B196B283-BAB4-101A-B69C-00AA00341D07"), 4);
var connectionPointContainer = wrappers.Wrap(unknown, new Guid("B196B284-BAB4-101A-B69C-00AA00341D07"), 5);
//TODO: optional (?) IConnectionPoint "B196B286-BAB4-101A-B69C-00AA00341D07" functionCount=8 (3 + 5)
//TODO: optional (if IExpando) IDispatchEx "A6EF9860-C720-11d0-9337-00A0C90DCAA9" functionCount=15 (3 + 4 + 8)
//TODO: optional (if IEnumerable) IEnumVARIANT "00020404-0000-0000-C000-000000000046" functionCount=7 (3 + 4)
hooks.Add(new CcwHook(comObject, unknown, wrappers));
foreach (var interfacePointer in interfacePointers)
hooks.Add(new CcwHook(comObject, interfacePointer, wrappers));
hooks.Add(new CcwHook(comObject, supportErrorInfo, wrappers));
hooks.Add(new CcwHook(comObject, provideClassInfo, wrappers));
hooks.Add(new CcwHook(comObject, connectionPointContainer, wrappers));
Marshal.Release(unknown);
foreach (var interfacePointer in interfacePointers)
Marshal.Release(interfacePointer);
Marshal.Release(supportErrorInfo.Wrapper);
Marshal.Release(provideClassInfo.Wrapper);
Marshal.Release(connectionPointContainer.Wrapper);
}
public static void Add(IDisposable obj)
{
Debug.WriteLine(string.Format("Adding object `{0}`",
obj.GetType().Name));
StringBuilder sb = new StringBuilder();
// Shove the first frame and build a stack trace
bool first = true;
foreach (StackFrame frame in new StackTrace(true).GetFrames())
{
if (first)
{
first = false;
continue;
}
sb.Append(string.Format("> [{0}] {1} {2}",
frame.GetMethod().DeclaringType.FullName,
frame.GetMethod().ToString(),
frame.GetFileName() == null ?
Environment.NewLine :
frame.ToString()));
}
_dict.Add(RuntimeHelpers.GetHashCode(obj),
new DisposableObject(obj, sb.ToString()));
}
public static void DisposeMembers(this IDisposable disposable)
{
Debug.Assert(false, "親がDisposeだからといって子供を全部Disposeするのはやりすぎ。再考。");
var type = disposable.GetType();
var properties = type.GetProperties(
BindingFlags.Instance
| BindingFlags.Public
| BindingFlags.NonPublic);
var disposedObjects = new List <IDisposable>();
foreach (var property in properties.Where(p => p.CanRead))
{
var disposableProperty = property.GetValue(disposable) as IDisposable;
if (disposableProperty != null)
{
disposableProperty.Dispose();
disposedObjects.Add(disposableProperty);
}
}
var fields = type.GetFields(
BindingFlags.Instance
| BindingFlags.Public
| BindingFlags.NonPublic);
foreach (var field in fields)
{
var disposableField = field.GetValue(disposable) as IDisposable;
if (disposableField != null && !disposedObjects.Contains(disposableField))
{
disposableField.Dispose();
}
}
}
public DeterministicFinalizer(IDisposable comObject)
{
var unknown = Marshal.GetIUnknownForObject(comObject);
//TODO: GetIDispatchForObject if any interfaces are ComInterfaceType InterfaceIsDual or InterfaceIsIDispatch.
var interfacePointers = comObject.GetType()
.GetInterfaces()
.Where(Marshal.IsTypeVisibleFromCom)
.Select(@interface => Marshal.GetComInterfaceForObject(comObject, @interface))
.ToList();
var supportErrorInfo = wrappers.Wrap(unknown, new Guid("df0b3d60-548f-101b-8e65-08002b2bd119"), 4);
var provideClassInfo = wrappers.Wrap(unknown, new Guid("B196B283-BAB4-101A-B69C-00AA00341D07"), 4);
var connectionPointContainer = wrappers.Wrap(unknown, new Guid("B196B284-BAB4-101A-B69C-00AA00341D07"), 5);
//TODO: optional (?) IConnectionPoint "B196B286-BAB4-101A-B69C-00AA00341D07" functionCount=8 (3 + 5)
//TODO: optional (if IExpando) IDispatchEx "A6EF9860-C720-11d0-9337-00A0C90DCAA9" functionCount=15 (3 + 4 + 8)
//TODO: optional (if IEnumerable) IEnumVARIANT "00020404-0000-0000-C000-000000000046" functionCount=7 (3 + 4)
hooks.Add(new CcwHook(comObject, unknown, wrappers));
foreach (var interfacePointer in interfacePointers)
{
hooks.Add(new CcwHook(comObject, interfacePointer, wrappers));
}
hooks.Add(new CcwHook(comObject, supportErrorInfo, wrappers));
hooks.Add(new CcwHook(comObject, provideClassInfo, wrappers));
hooks.Add(new CcwHook(comObject, connectionPointContainer, wrappers));
Marshal.Release(unknown);
foreach (var interfacePointer in interfacePointers)
{
Marshal.Release(interfacePointer);
}
Marshal.Release(supportErrorInfo.Wrapper);
Marshal.Release(provideClassInfo.Wrapper);
Marshal.Release(connectionPointContainer.Wrapper);
}
internal static void RegisterForDispose(this IStardustContext currentContext, IDisposable instance)
{
try
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Register disposable item {instance.GetType().FullName}");
}
var container = GetStardustContextProvider(currentContext);
lock (container)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"before insert: Dispose list size {container.DisposeList?.Count}");
}
container.DisposeList?.Add(instance);
if (DoLoggingLight)
{
Logging.DebugMessage($"after insert: Dispose list size {container.DisposeList?.Count}");
}
}
}
catch (Exception ex)
{
ex.Log();
}
}
internal static RECT GetNotifyIconArea(IDisposable notifyicon)
{
var field = notifyicon.GetType().GetField("id", BindingFlags.NonPublic | BindingFlags.Instance);
var num = (int)field.GetValue(notifyicon);
var fieldInfo = notifyicon.GetType().GetField("window", BindingFlags.NonPublic | BindingFlags.Instance);
var window = (NativeWindow)fieldInfo.GetValue(notifyicon);
var notifyiconidentifier2 = new NOTIFYICONIDENTIFIER {
hWnd = window.Handle, uID = (uint)num
};
notifyiconidentifier2.cbSize = (uint)Marshal.SizeOf(notifyiconidentifier2);
RECT rect;
Shell_NotifyIconGetRect(ref notifyiconidentifier2, out rect);
return(rect);
}
/// <summary>
/// Throws an exception if this object is disposed
/// </summary>
/// <param name="disposable">Disposable object</param>
/// <param name="isDisposed">Is this object disposed</param>
public static void GuardNotDisposed(this IDisposable disposable, bool isDisposed)
{
if (isDisposed)
{
throw new InvalidOperationException(
$"{disposable.GetType().FullName} is disposed");
}
}
private static Point GetNotifyIconPosition(IDisposable notifyicon)
{
var field = notifyicon.GetType().GetField("id", BindingFlags.NonPublic | BindingFlags.Instance);
var num = (int)field.GetValue(notifyicon);
var fieldInfo = notifyicon.GetType().GetField("window", BindingFlags.NonPublic | BindingFlags.Instance);
var window = (NativeWindow)fieldInfo.GetValue(notifyicon);
var notifyiconidentifier2 = new NOTIFYICONIDENTIFIER {
hWnd = window.Handle, uID = (uint)num
};
notifyiconidentifier2.cbSize = (uint)Marshal.SizeOf(notifyiconidentifier2);
RECT rect;
Shell_NotifyIconGetRect(ref notifyiconidentifier2, out rect);
return(new Point(rect.left + (rect.right - rect.left) / 2, rect.top + (rect.bottom - rect.top) / 2));
}
public Task <Stream> ReadFileAsync(__VsRemoteControlBehaviorOnStale behavior)
{
var clientType = _client.GetType();
var readFileAsyncMethod = clientType.GetMethod("ReadFileAsync");
var streamTask = (Task <Stream>)readFileAsyncMethod.Invoke(_client, new object[] { (int)behavior });
return(streamTask);
}
public static void Disable(IDisposable service)
{
try
{
service.Dispose();
servicesToBeDisposed.Remove(service);
logging.Debug($"{service.GetType().Name + (service.GetType().GetTypeInfo().GenericTypeArguments.Length > 0 ? $"<{string.Join(", ", service.GetType().GenericTypeArguments.Select(type => type.Name))}>" : "")} disposed");
}
catch (Exception e)
{
logging.Error($"" +
$"Unhandled exception while disposing Service {service.GetType().Name}: {e.Message}" +
$"\nSource: {(e.Source != null ? e.Source : "Unknown")}" +
$"\nStackTrace: {e.StackTrace}");
throw;
}
}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
private static DbConnection CreateDBIfRequired(string username, string connectionString)
{
if (!connectionString.Contains(_SQL_CE_Tag))
{
return(null);
}
DbConnection conn = null;
try {
conn = CreateNewSqlCeConnection(connectionString, false);
if (string.Compare(conn.Database.Trim(), _SQL_CE_Tag, StringComparison.OrdinalIgnoreCase) != 0)
{
conn.Open();
return(conn);
}
conn.Dispose();
conn = null;
} catch (TypeLoadException e) {
throw new ArgumentException(AtlasWeb.SqlHelper_SqlEverywhereNotInstalled, e);
}
string fileName = GetFullDBFileName(username, "_DB.spf");
bool needToCreateDB = (File.Exists(fileName) == false);
connectionString = connectionString.Replace(_SQL_CE_Tag, fileName);
if (needToCreateDB)
{
using (IDisposable engine = (IDisposable)Activator.CreateInstance(GetSqlCeType("SqlCeEngine"), new object[] { connectionString })) {
engine.GetType().InvokeMember("CreateDatabase", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance,
null, engine, null, CultureInfo.InvariantCulture);
}
using (conn = CreateNewSqlCeConnection(connectionString, true)) {
DbCommand cmd = conn.CreateCommand();
if (username == null)
{
cmd.CommandText = "CREATE TABLE ApplicationProperties (PropertyName nvarchar(256), PropertyValue nvarchar(256))";
cmd.ExecuteNonQuery();
}
else
{
cmd.CommandText = "CREATE TABLE UserProperties (PropertyName nvarchar(256), PropertyValue nvarchar(256))";
cmd.ExecuteNonQuery();
cmd = conn.CreateCommand();
cmd.CommandText = "CREATE TABLE Roles (UserName nvarchar(256), RoleName nvarchar(256))";
cmd.ExecuteNonQuery();
cmd = conn.CreateCommand();
cmd.CommandText = "CREATE TABLE Settings (PropertyName nvarchar(256), PropertyStoredAs nvarchar(1), PropertyValue nvarchar(2048))";
cmd.ExecuteNonQuery();
}
}
}
return(CreateNewSqlCeConnection(connectionString, true));
}
public static void NotifyMissingDispose(IDisposable disposable)
{
bool flag = disposable == null;
if (!flag)
{
UnityEngine.Debug.LogError("An IDisposable instance of type '" + disposable.GetType().FullName + "' has not been disposed.");
}
}
/// <summary>
/// Registers an object instance for tracking.
/// </summary>
/// <param name="value">The instance to track.</param>
/// <para>If you are calling this method from your own <see cref="IDisposable"/> implementation it should be called from the constructor.</para>
/// <remarks>
/// <para>Null values are ignored.</para>
/// </remarks>
public static void RegisterInstance(IDisposable value)
{
if (value == null)
{
return;
}
RegisterInstance(value.GetType(), value);
}
internal IJobable(IDisposable obj, string isDisposedProperty)
{
_Object = obj;
_IsDisposedProperty = obj.GetType().GetProperty(isDisposedProperty);
if (_IsDisposedProperty == null)
{
throw new Exception("Property not found: '" + isDisposedProperty + "'");
}
}
private static void RegisterForDisposalWithPipeline(object response, IDisposable disposable)
{
try
{
if (response == null)
{
Log.Error($"HttpContext.Response is null, unable to register {disposable.GetType().FullName}");
return;
}
var disposalRegisterMethod = response.GetType().GetMethod("RegisterForDispose");
disposalRegisterMethod.Invoke(response, new object[] { disposable });
}
catch (Exception ex)
{
Log.Error(ex, $"Unable to register {disposable.GetType().FullName}");
}
}
/// <summary>
/// Throws if disposed.
/// </summary>
/// <param name="disposable">The disposable.</param>
/// <param name="isDisposed">Whether this <see cref="IDisposable" /> is disposed.</param>
public static void ThrowIfDisposed(this IDisposable disposable, bool isDisposed)
{
if (!isDisposed)
{
return;
}
throw new ObjectDisposedException(disposable.GetType().FullName);
}
public void Free(IDisposable obj)
{
Type type = obj.GetType();
if (Get(this.usingObjects, type).Remove(obj))
{
Get(this.freeObjects, type).Add(obj);
}
}
public void GivenTestMethodHasSomeParameters_WhenTestRun_ThenParametersAreGenerated(int value, IDisposable disposable)
{
// Arrange
// Act
// Assert
value.Should().NotBe(default(int));
disposable.Should().NotBeNull();
disposable.GetType().Name.Should().StartWith("IDisposableProxy", "that way we know it was mocked.");
}
public void GivenTestMethodHasSomeInlineParameters_WhenTestRun_ThenParametersAreGenerated(int value, IDisposable disposable)
{
// Arrange
// Act
// Assert
value.Should().Be(100);
disposable.Should().NotBeNull();
disposable.GetType().Name.Should().Contain("Proxy", "that way we know it was mocked.");
}
private static string getShortcutText(IDisposable mi)
{
var t = (string)mi.GetType().InvokeMember(
@"GetShortcutText",
BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance,
null,
mi,
new object[] { });
return t;
}
private static void DisposeOf(IDisposable disposable)
{
try
{
disposable.Dispose();
}
catch (ObjectDisposedException ex)
{
// not supposed to happen, but sometimes does
var logger = LoggerFactory.GetCurrentClassLogger();
var msg = string.Format("Object of type {0} raised ObjectDisposedException during disposal",
disposable.GetType());
logger.Warn(msg, ex);
}
catch (Exception ex)
{
var logger = LoggerFactory.GetCurrentClassLogger();
var msg = string.Format("Object of type {0} raised an exception during disposal: {1}",
disposable.GetType(),
ex.Message);
logger.Error(msg, ex);
}
}
public static void SilentDispose(IDisposable disposable)
{
if (disposable != null)
{
try
{
disposable.Dispose();
}
catch (Exception e)
{
Trace.TraceWarning("[{0}] Failed to dispose object of type [{1}]. {2}", typeof(DisposeHelper), disposable.GetType(), e);
}
}
}
private static void Dispose(IDisposable disposable, Boolean isDisposing)
{
Debug.Assert(disposable != null);
// Dispose of the fields in each type down to, but excluding, System.Object
Type type = disposable.GetType();
do {
FieldInfo[] instanceFields = type.GetFields(AllInstanceMembers);
if (isDisposing) {
DisposableExtensions.ReleaseManagedResources(disposable, instanceFields);
}
DisposableExtensions.ReleaseUnmanagedResources(disposable, instanceFields);
}
while ((type = type.BaseType) != typeof(Object));
if (isDisposing) {
GC.SuppressFinalize(disposable);
}
}
public void Start(string bootstrapperName, Dictionary<string, string> properties, MarshalByRefObject remoteListener)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var domainSetup = AppDomain.CurrentDomain.SetupInformation;
System.Environment.CurrentDirectory = domainSetup.ApplicationBase;
// TODO -- need to handle exceptions gracefully here
EventAggregator.Start((IRemoteListener) remoteListener);
properties.Each(x => PackageRegistry.Properties[x.Key] = x.Value);
var loader = BottleServiceApplication.FindLoader(bootstrapperName);
_shutdown = loader.Load();
EventAggregator.SendMessage(new LoaderStarted
{
LoaderTypeName = _shutdown.GetType().FullName
});
}
public void Start(string bootstrapperName, Dictionary<string, string> properties, MarshalByRefObject remoteListener)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
//var domainSetup = AppDomain.CurrentDomain.SetupInformation;
// TODO -- what the hell here? This is bad bad bad.
//System.Environment.CurrentDirectory = domainSetup.ApplicationBase;
// TODO -- need to handle exceptions gracefully here
EventAggregator.Start((IRemoteListener) remoteListener);
var loader = ApplicationLoaderFinder.FindLoader(bootstrapperName);
_shutdown = loader.Load(properties);
EventAggregator.SendMessage(new LoaderStarted
{
LoaderTypeName = _shutdown.GetType().FullName
});
}
public static void Add(IDisposable obj)
{
Debug.WriteLine(string.Format("Adding object `{0}`",
obj.GetType().Name));
var sb = new StringBuilder();
// Shove the first frame and build a stack trace
foreach (StackFrame frame in new StackTrace(true).GetFrames().Skip(1))
{
var method = frame.GetMethod();
sb.Append(string.Format("> [{0}] {1} {2}",
method.DeclaringType != null? method.DeclaringType.FullName : "",
method.ToString(),
frame.GetFileName() == null ?
Environment.NewLine :
frame.ToString()));
}
_dict.Add(RuntimeHelpers.GetHashCode(obj),
new DisposableObject(obj, sb.ToString()));
}
public static void ThrowIfDisposed(IDisposable obj)
{
if (obj.IsDisposed) throw new ObjectDisposedException(obj.GetType().FullName);
}
private static Point GetNotifyIconPosition(IDisposable notifyicon)
{
var field = notifyicon.GetType().GetField("id", BindingFlags.NonPublic | BindingFlags.Instance);
var num = (int) field.GetValue(notifyicon);
var fieldInfo = notifyicon.GetType().GetField("window", BindingFlags.NonPublic | BindingFlags.Instance);
var window = (NativeWindow) fieldInfo.GetValue(notifyicon);
var notifyiconidentifier2 = new NOTIFYICONIDENTIFIER {hWnd = window.Handle, uID = (uint) num};
notifyiconidentifier2.cbSize = (uint) Marshal.SizeOf(notifyiconidentifier2);
RECT rect;
Shell_NotifyIconGetRect(ref notifyiconidentifier2, out rect);
return new Point(rect.left + (rect.right - rect.left) / 2, rect.top + (rect.bottom - rect.top) / 2);
}
internal static RECT GetNotifyIconArea(IDisposable notifyicon)
{
var field = notifyicon.GetType().GetField("id", BindingFlags.NonPublic | BindingFlags.Instance);
var num = (int)field.GetValue(notifyicon);
var fieldInfo = notifyicon.GetType().GetField("window", BindingFlags.NonPublic | BindingFlags.Instance);
var window = (NativeWindow)fieldInfo.GetValue(notifyicon);
var notifyiconidentifier2 = new NOTIFYICONIDENTIFIER { hWnd = window.Handle, uID = (uint)num };
notifyiconidentifier2.cbSize = (uint)Marshal.SizeOf(notifyiconidentifier2);
RECT rect;
Shell_NotifyIconGetRect(ref notifyiconidentifier2, out rect);
return rect;
}
public static void Remove(IDisposable obj)
{
Debug.WriteLine(string.Format("Removing object `{0}`",
obj.GetType().Name));
_dict.Remove(RuntimeHelpers.GetHashCode(obj));
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
TryCloseForm();
if (listBox1.SelectedItem == null)
return;
Assembly demo = Assembly.Load(listBox1.SelectedItem.ToString());
Type[] types = demo.GetExportedTypes();
foreach (Type type in types)
{
if (type.BaseType.Name.Equals("Game"))
{
game = (IDisposable)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
bool librariesOk = (bool)type.InvokeMember("TestLibraries", BindingFlags.InvokeMethod, null, game, null);
if (librariesOk == false)
return;
new Thread(DemoThread).Start();
while (form == null)
{
form = (Form)game.GetType().InvokeMember("Form", BindingFlags.GetProperty, null, game, null);
}
form.HandleCreated += new EventHandler(form_HandleCreated);
break;
}
}
}
