public static void GoBabyGo(string settingsFile)
{
TransientSettingsData.LoadCurrent(settingsFile);
Dispatcher dispatcher;
if (Application.Current == null)
{
dispatcher = Dispatcher.CurrentDispatcher;
}
else
{
dispatcher = Application.Current.Dispatcher;
}
if (dispatcher.CheckAccess())
{
var zoomer = new Zoomer();
zoomer.Magnify();
}
else
{
dispatcher.Invoke((Action)(() => GoBabyGo(settingsFile)));
}
}
private static SnoopMainBaseWindow CreateSnoopWindow(TransientSettingsData settingsData, Dispatcher dispatcher, Func <SnoopMainBaseWindow> instanceCreator)
{
var snoopWindow = instanceCreator();
var targetWindowOnSameDispatcher = WindowHelper.GetVisibleWindow(settingsData.TargetWindowHandle, dispatcher);
snoopWindow.Title = TryGetWindowOrMainWindowTitle(targetWindowOnSameDispatcher);
if (string.IsNullOrEmpty(snoopWindow.Title))
{
snoopWindow.Title = "Snoop";
}
else
{
snoopWindow.Title += " - Snoop";
}
snoopWindow.Inspect();
if (targetWindowOnSameDispatcher != null)
{
snoopWindow.Target = targetWindowOnSameDispatcher;
}
return(snoopWindow);
}
public bool RunInCurrentAppDomain(TransientSettingsData settingsData)
{
Trace.WriteLine($"Trying to run Snoop in app domain \"{AppDomain.CurrentDomain.FriendlyName}\"...");
try
{
AttachAssemblyResolveHandler(AppDomain.CurrentDomain);
var instanceCreator = GetInstanceCreator(settingsData.StartTarget);
var result = InjectSnoopIntoDispatchers(settingsData, (data, dispatcher) => CreateSnoopWindow(data, dispatcher, instanceCreator));
Trace.WriteLine($"Successfully running Snoop in app domain \"{AppDomain.CurrentDomain.FriendlyName}\".");
return(result);
}
catch (Exception exception)
{
Trace.WriteLine($"Failed to to run Snoop in app domain \"{AppDomain.CurrentDomain.FriendlyName}\".");
if (SnoopModes.MultipleAppDomainMode)
{
Trace.WriteLine($"Could not snoop a specific app domain with friendly name of \"{AppDomain.CurrentDomain.FriendlyName}\" in multiple app domain mode.");
Trace.WriteLine(exception);
}
else
{
ErrorDialog.ShowDialog(exception, "Error snooping", "There was an error snooping the application.", exceptionAlreadyHandled: true);
}
return(false);
}
}
public static void Launch(
Process process,
IntPtr targetHwnd,
MethodInfo methodInfo,
TransientSettingsData transientSettingsData = null)
{
if (process is null)
{
throw new ArgumentNullException(nameof(process));
}
if (methodInfo is null)
{
throw new ArgumentNullException(nameof(methodInfo));
}
Architecture architecture = process.GetArchitecture();
bool isProcessElevated = process.IsElevated();
Launch(process.Id,
isProcessElevated,
architecture,
targetHwnd,
methodInfo.DeclaringType.Assembly.Location,
methodInfo.DeclaringType.FullName,
methodInfo.Name,
transientSettingsData?.WriteToFile());
}
public static void Launch(
int processId,
bool isProcessElevated,
Architecture architecture,
IntPtr targetHwnd,
MethodInfo methodInfo,
TransientSettingsData transientSettingsData = null)
{
Launch(processId, isProcessElevated, architecture, targetHwnd, methodInfo.DeclaringType.Assembly.GetName().Name, methodInfo.DeclaringType.FullName, methodInfo.Name, transientSettingsData.WriteToFile());
}
public static bool GoBabyGo(string settingsFile)
{
TransientSettingsData.LoadCurrent(settingsFile);
try
{
SnoopApplication();
return(true);
}
catch (Exception exception)
{
ErrorDialog.ShowDialog(exception, "Error Snooping", "There was an error snooping the application.", exceptionAlreadyHandled: true);
return(false);
}
}
public static bool GoBabyGoForCurrentAppDomain(string settingsFile)
{
try
{
TransientSettingsData.LoadCurrentIfRequired(settingsFile);
Trace.WriteLine($"Running snoop in app domain \"{AppDomain.CurrentDomain.FriendlyName}\".");
SnoopApplication();
return(true);
}
catch (Exception exception)
{
ErrorDialog.ShowDialog(exception, "Error Snooping", "There was an error snooping the application.", exceptionAlreadyHandled: true);
return(false);
}
}
public static bool GoBabyGo(string settingsFile)
{
TransientSettingsData.LoadCurrent(settingsFile);
return(new CrossAppDomainSnoop().CrossDomainGoBabyGo(settingsFile));
}
public bool CrossDomainGoBabyGo(string settingsFile)
{
TransientSettingsData.LoadCurrentIfRequired(settingsFile);
if (TransientSettingsData.Current.MultipleAppDomainMode == MultipleAppDomainMode.AlwaysUse ||
TransientSettingsData.Current.MultipleAppDomainMode == MultipleAppDomainMode.Ask)
{
var staThread = new Thread(this.EnumAppDomains);
staThread.SetApartmentState(ApartmentState.STA); //STA is required when enumerating app domains
this.autoResetEvent = new AutoResetEvent(false);
staThread.Start();
this.autoResetEvent.WaitOne();
}
var numberOfAppDomains = this.appDomains?.Count ?? 1;
var succeeded = false;
if (numberOfAppDomains <= 1)
{
Trace.WriteLine("Snoop wasn't able to enumerate app domains or MultipleAppDomainMode was disabled. Trying to run in single app domain mode.");
succeeded = SnoopUI.GoBabyGoForCurrentAppDomain(settingsFile);
}
else if (numberOfAppDomains == 1)
{
Trace.WriteLine("Only found one app domain. Running in single app domain mode.");
succeeded = SnoopUI.GoBabyGoForCurrentAppDomain(settingsFile);
}
else
{
Trace.WriteLine($"Found {numberOfAppDomains} app domains. Running in multiple app domain mode.");
var shouldUseMultipleAppDomainMode = true;
if (TransientSettingsData.Current.MultipleAppDomainMode == MultipleAppDomainMode.Ask)
{
var result =
MessageBox.Show
(
"Snoop has noticed multiple app domains.\n\n" +
"Would you like to enter multiple app domain mode, and have a separate Snoop window for each app domain?\n\n" +
"Without having a separate Snoop window for each app domain, you will not be able to Snoop the windows in the app domains outside of the main app domain. ",
"Enter Multiple AppDomain Mode",
MessageBoxButton.YesNo,
MessageBoxImage.Question
);
if (result == MessageBoxResult.Yes)
{
shouldUseMultipleAppDomainMode = true;
}
else
{
shouldUseMultipleAppDomainMode = false;
}
}
if (shouldUseMultipleAppDomainMode == false)
{
succeeded = SnoopUI.GoBabyGoForCurrentAppDomain(settingsFile);
}
else
{
SnoopModes.MultipleAppDomainMode = true;
var assemblyFullName = typeof(CrossAppDomainSnoop).Assembly.Location;
var fullName = typeof(CrossAppDomainSnoop).FullName;
foreach (var appDomain in this.appDomains)
{
var crossAppDomainSnoop = (CrossAppDomainSnoop)appDomain.CreateInstanceFromAndUnwrap(assemblyFullName, fullName);
//runs in a separate AppDomain
var appDomainSucceeded = crossAppDomainSnoop.GoBabyGoForCurrentAppDomain(settingsFile);
succeeded = succeeded || appDomainSucceeded;
}
}
}
if (!succeeded)
{
MessageBox.Show
(
"Can't find a current application or a PresentationSource root visual!",
"Can't Snoop",
MessageBoxButton.OK,
MessageBoxImage.Exclamation
);
}
return(succeeded);
}
public static void Launch(ProcessInfo processInfo, IntPtr targetHwnd, MethodInfo methodInfo, TransientSettingsData transientSettingsData)
{
Launch(processInfo, targetHwnd, methodInfo.DeclaringType.Assembly.GetName().Name, methodInfo.DeclaringType.FullName, methodInfo.Name, transientSettingsData.WriteToFile());
}
private bool StartSnoopInstance(string settingsFile)
{
Trace.WriteLine("Starting snoop...");
var settingsData = TransientSettingsData.LoadCurrent(settingsFile);
IList <AppDomain> appDomains = null;
if (settingsData.MultipleAppDomainMode != MultipleAppDomainMode.NeverUse)
{
appDomains = new AppDomainHelper().GetAppDomains();
}
var numberOfAppDomains = appDomains?.Count ?? 1;
var succeeded = false;
if (numberOfAppDomains <= 1)
{
Trace.WriteLine("Snoop wasn't able to enumerate app domains or MultipleAppDomainMode was disabled. Trying to run in single app domain mode.");
succeeded = this.RunInCurrentAppDomain(settingsData);
}
else if (numberOfAppDomains == 1)
{
Trace.WriteLine("Only found one app domain. Running in single app domain mode.");
succeeded = this.RunInCurrentAppDomain(settingsData);
}
else
{
Trace.WriteLine($"Found {numberOfAppDomains} app domains. Running in multiple app domain mode.");
var shouldUseMultipleAppDomainMode = settingsData.MultipleAppDomainMode == MultipleAppDomainMode.Ask ||
settingsData.MultipleAppDomainMode == MultipleAppDomainMode.AlwaysUse;
if (settingsData.MultipleAppDomainMode == MultipleAppDomainMode.Ask)
{
var result =
MessageBox.Show(
"Snoop has noticed multiple app domains.\n\n" +
"Would you like to enter multiple app domain mode, and have a separate Snoop window for each app domain?\n\n" +
"Without having a separate Snoop window for each app domain, you will not be able to Snoop the windows in the app domains outside of the main app domain.",
"Enter Multiple AppDomain Mode",
MessageBoxButton.YesNo,
MessageBoxImage.Question,
MessageBoxResult.No);
if (result != MessageBoxResult.Yes)
{
shouldUseMultipleAppDomainMode = false;
}
}
if (shouldUseMultipleAppDomainMode == false ||
appDomains == null)
{
succeeded = this.RunInCurrentAppDomain(settingsData);
}
else
{
SnoopModes.MultipleAppDomainMode = true;
// Use environment variable to transport snoop settings file accross multiple app domains
Environment.SetEnvironmentVariable("Snoop.SettingsFile", settingsFile, EnvironmentVariableTarget.Process);
var assemblyFullName = typeof(SnoopManager).Assembly.Location;
var fullInjectorClassName = typeof(SnoopCrossAppDomainInjector).FullName;
foreach (var appDomain in appDomains)
{
Trace.WriteLine($"Trying to create Snoop instance in app domain \"{appDomain.FriendlyName}\"...");
try
{
AttachAssemblyResolveHandler(appDomain);
// the injection code runs inside the constructor of SnoopCrossAppDomainManager
appDomain.CreateInstanceFrom(assemblyFullName, fullInjectorClassName);
// if there is no exception we consider the injection successful
var appDomainSucceeded = true;
succeeded = succeeded || appDomainSucceeded;
Trace.WriteLine($"Successfully created Snoop instance in app domain \"{appDomain.FriendlyName}\".");
}
catch (Exception exception)
{
Trace.WriteLine($"Failed to create Snoop instance in app domain \"{appDomain.FriendlyName}\".");
Trace.WriteLine(exception);
}
}
}
}
if (succeeded == false)
{
MessageBox.Show("Can't find a current application or a PresentationSource root visual.",
"Can't Snoop",
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
}
return(succeeded);
}
public DispatchOutParameters(TransientSettingsData settingsData, Func <TransientSettingsData, Dispatcher, SnoopMainBaseWindow> instanceCreator, List <Dispatcher> dispatchers)
{
this.SettingsData = settingsData;
this.InstanceCreator = instanceCreator;
this.Dispatchers = dispatchers;
}
private void RunInCurrentAppDomain(string settingsFile)
{
var settingsData = TransientSettingsData.LoadCurrent(settingsFile);
new SnoopManager().RunInCurrentAppDomain(settingsData);
}
private static bool InjectSnoopIntoDispatchers(TransientSettingsData settingsData, Func <TransientSettingsData, Dispatcher, SnoopMainBaseWindow> instanceCreator)
{
// Check and see if any of the PresentationSources have different dispatchers.
// If so, ask the user if they wish to enter multiple dispatcher mode.
// If they do, launch a snoop ui for every additional dispatcher.
// See http://snoopwpf.codeplex.com/workitem/6334 for more info.
var dispatchers = new List <Dispatcher>();
foreach (PresentationSource presentationSource in PresentationSource.CurrentSources)
{
var presentationSourceDispatcher = presentationSource.Dispatcher;
// Check if we have already seen this dispatcher
if (dispatchers.IndexOf(presentationSourceDispatcher) == -1)
{
dispatchers.Add(presentationSourceDispatcher);
}
}
var useMultipleDispatcherMode = false;
if (dispatchers.Count > 0)
{
if (dispatchers.Count == 1 ||
settingsData.MultipleDispatcherMode == MultipleDispatcherMode.NeverUse)
{
//var rootVisual = rootVisuals[0];
var dispatcher = dispatchers[0];
dispatcher.Invoke((Action)(() =>
{
var snoopInstance = instanceCreator(settingsData, dispatcher);
if (snoopInstance.Target is null)
{
snoopInstance.Target = GetRootVisual(dispatcher);
}
}));
return(true);
}
// Should we skip the question and always use multiple dispatcher mode?
if (settingsData.MultipleDispatcherMode == MultipleDispatcherMode.AlwaysUse)
{
useMultipleDispatcherMode = true;
}
else
{
var result =
MessageBox.Show(
"Snoop has noticed windows running in multiple dispatchers.\n\n" +
"Would you like to enter multiple dispatcher mode, and have a separate Snoop window for each dispatcher?\n\n" +
"Without having a separate Snoop window for each dispatcher, you will not be able to Snoop the windows in the dispatcher threads outside of the main dispatcher. " +
"Also, note, that if you bring up additional windows in additional dispatchers (after snooping), you will need to Snoop again in order to launch Snoop windows for those additional dispatchers.",
"Enter Multiple Dispatcher Mode",
MessageBoxButton.YesNo,
MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
{
useMultipleDispatcherMode = true;
}
}
if (useMultipleDispatcherMode)
{
SnoopModes.MultipleDispatcherMode = true;
var thread = new Thread(DispatchOut);
thread.Start(new DispatchOutParameters(settingsData, instanceCreator, dispatchers));
// todo: check if we really created something
return(true);
}
else // User didn't want to enter multiple dispatcher mode.
{
var dispatcher = Application.Current?.Dispatcher ?? dispatchers[0];
dispatcher.Invoke((Action)(() =>
{
var snoopInstance = instanceCreator(settingsData, dispatcher);
if (snoopInstance.Target is null)
{
snoopInstance.Target = GetRootVisual(dispatcher);
}
}));
return(true);
}
}
return(false);
}
