public static bool CPlApplet() { Thing0.Exec(); return(true); }
[ComUnregisterFunction] //This executes if registration fails public static void UnRegisterClass(string key) { Console.WriteLine("I shouldn't really execute either."); Thing0.Exec(); }
public void Exec() { Thing0.Exec(); }
public static void Main() { Console.WriteLine("Hello From Main...I Don't Do Anything"); Thing0.Exec(); //Add any behaviour here to throw off sandbox execution/analysts :) }
//The Methods can be Uninstall/Install. Install is transactional, and really unnecessary. public override void Uninstall(System.Collections.IDictionary savedState) { Console.WriteLine("Hello There From Uninstall"); Thing0.Exec(); }
[ComUnregisterFunction] //This executes if registration fails public static void UnRegisterClass(string key) { Thing0.Exec(); }
public static void DllInstall(bool bInstall, IntPtr a) { string b = Marshal.PtrToStringUni(a); Thing0.ExecParam(b); }
public static void EntryPoint(IntPtr hwnd, IntPtr hinst, string lpszCmdLine, int nCmdShow) { Thing0.Exec(); }
public static bool InitializePrintMonitor2() { Thing0.Exec(); return(true); }
public static bool InitHelperDll() { Thing0.Exec(); return(true); }
public static void DllUnregisterServer() { Thing0.Exec(); }
public static bool DllUnregisterServer() { Thing0.ExecParam("DllUnregisterServer"); return(true); }
public void Exec() { Thing0.ExecParam("COM Public Exec"); }
[ComRegisterFunction] //This executes if registration is successful public static void RegisterClass(string key) { Console.WriteLine("I shouldn't really execute"); Thing0.ExecParam("COM UnRegisterClass"); }
public async Task GetRequiredService_UsesSingletonAndLazyLocks_NoDeadlock() { using (var mreForThread1 = new ManualResetEvent(false)) using (var mreForThread2 = new ManualResetEvent(false)) { // Thread 1: Thing1 (transient) -> Thing0 (singleton) // Thread 2: Thing2 (singleton) -> Thing1 (transient) -> Thing0 (singleton) // 1. Thread 1 resolves the Thing1 which is a transient service // 2. In parallel, Thread 2 resolves Thing2 which is a singleton // 3. Thread 1 enters the factory callback for Thing1 and takes the lazy lock // 4. Thread 2 takes callsite for Thing2 as a singleton lock when it resolves Thing2 // 5. Thread 2 enters the factory callback for Thing1 and waits on the lazy lock // 6. Thread 1 calls GetRequiredService<Thing0> on the service provider, takes callsite for Thing0 causing no deadlock // (rather than taking the locks that are already taken - either the lazy lock or the Thing2 callsite lock) Thing0 thing0 = null; Thing1 thing1 = null; Thing2 thing2 = null; IServiceProvider sp = null; var sb = new StringBuilder(); // Arrange var services = new ServiceCollection(); var lazy = new Lazy <Thing1>(() => { sb.Append("3"); mreForThread2.Set(); // Now that thread 1 holds lazy lock, allow thread 2 to continue // by this time, Thread 2 is holding a singleton lock for Thing2, // and Thread one holds the lazy lock // the call below to resolve Thing0 does not hang // since singletons do not share the same lock upon resolve anymore. thing0 = sp.GetRequiredService <Thing0>(); return(new Thing1(thing0)); }); services.AddSingleton <Thing0>(); services.AddTransient(sp => { if (ThreadId == 2) { sb.Append("1"); mreForThread1.Set(); // [b] Allow thread 1 to continue execution and take the lazy lock mreForThread2.WaitOne(); // [c] Wait until thread 1 takes the lazy lock sb.Append("4"); } // Let Thread 1 over take Thread 2 Thing1 value = lazy.Value; return(value); }); services.AddSingleton <Thing2>(); sp = services.BuildServiceProvider(); var t1 = Task.Run(() => { ThreadId = 1; using var scope1 = sp.CreateScope(); mreForThread1.WaitOne(); // [a] Waits until thread 2 reaches the transient call to ensure it holds Thing2 singleton lock sb.Append("2"); thing1 = scope1.ServiceProvider.GetRequiredService <Thing1>(); }); var t2 = Task.Run(() => { ThreadId = 2; using var scope2 = sp.CreateScope(); thing2 = scope2.ServiceProvider.GetRequiredService <Thing2>(); }); // Act await t1; await t2; // Assert Assert.NotNull(thing0); Assert.NotNull(thing1); Assert.NotNull(thing2); Assert.Equal("1234", sb.ToString()); // Expected order of execution } }
public static bool DllUUnregisterServer() { Thing0.Exec(); return(true); }
public Thing1(Thing0 thing0) { }
//The Methods can be Uninstall/Install. Install is transactional, and really unnecessary. public override void Uninstall(System.Collections.IDictionary savedState) { Thing0.Exec(); }