C#

btn_Program.Enabled = false;

void btn_Program_Click(object sender, EventArgs e)
{
   // ... your code here ...
}

void btn_Program_Click(object sender, EventArgs e)
{
   // Disable the button whose Click event started this method
   System.Windows.Forms.Button methodStartingControl = sender as System.Windows.Forms.Button;
   if(methodStartingControl != null)
   {
       methodStartingControl.Enabled = false;
   }

   // ... your code here ...

   // Re-enable the previously-disabled button
   if(methodStartingControl != null)
   {
       methodStartingControl.Enabled = true;
   }
}

MJL Rademakers wrote:

Activator.CreateInstance()

namespace PIEBALD.Lib
{
    public static partial class LibSys
    {
        public static System.Reflection.Assembly
        DynamicLoad
        (
            string Filename
        )
        {
            System.Reflection.Assembly result ;

            System.IO.FileInfo fil = PIEBALD.Lib.LibFil.GetExpandedFileInfo ( Filename ) ;

            try
            {
                /*\
                |*| This is the common way to load an assembly:
                |*| result = System.Reflection.Assembly.LoadFrom ( Filename ) ;
                |*|
                |*| The following is my take on a technique suggested by Sacha Barber:
                \*/

                result = System.AppDomain.CreateDomain 
                    ( System.IO.Path.GetFileNameWithoutExtension ( fil.Name ) ).
                    Load ( System.IO.File.ReadAllBytes ( fil.FullName ) ) ;
            }
            catch ( System.Exception err )
            {
                throw ( new System.InvalidOperationException
                (
                    System.String.Format
                    (
                        "Could not load an assembly from file {0}"
                    ,
                        Filename
                    )
                ,
                    err
                ) ) ;
            }

            return ( result ) ;
        }
    }

    public static partial class LibSys
    {
        public static T
        DynamicLoad<T>
        (
            string          Filename
        ,
            string          Typename
        ,
            params object[] Parameters
        )
        {
            T result = default(T) ;
            
            System.Reflection.Assembly assm = DynamicLoad ( Filename ) ;

            System.Type type = assm.GetType ( Typename ) ;

            if ( type == null )
            {
                throw ( new System.InvalidOperationException
                (
                    System.String.Format
                    (
                        "The assembly in file {0} does not contain a public type named {1}"
                    ,
                        Filename
                    ,
                        Typename
                    )
                ) ) ;
            }

            if ( !typeof(T).IsAssignableFrom ( type ) )
            {
                throw ( new System.InvalidOperationException
                (
                    System.String.Format
                    (
                        "Type {0} in file {1} does not implement or derive from {2}"
                    ,
                        type.Name
                    ,
                        Filename
                    ,
                        typeof(T).FullName
                    )
                ) ) ;
            }

            System.Reflection.ConstructorInfo cons = type.GetConstructor
            (
                PIEBALD.Lib.LibSys.GetTypes ( Parameters ).ToArray()
            ) ;

            if ( cons == null )
            {
                throw ( new System.InvalidOperationException
                (
                    System.String.Format
                    (
                        "Type {0} in file {1} does not have the specified constructor"
                    ,
                        type.Name
                    ,
                        Filename
                    )
                ) ) ;
            }

            try
            {
                result = (T) cons.Invoke
                (
                    Parameters
                ) ;
            }
            catch ( System.Exception err )
            {
                throw ( new System.InvalidOperationException
                (
                    System.String.Format
                    (
                        "Unable to instantiate a {0}"
                    ,
                        type.FullName
                    ) 
                ,
                    err
                ) ) ;
            }

            return ( result ) ;
        }
    }
}

107      public class PluginLoader : MarshalByRefObject {
108          Assembly a;
109          public PluginLoader(){
110              System.Runtime.Remoting.Lifetime.LifetimeServices.LeaseTime = new TimeSpan(1000, 0, 0, 0);
111          }
112          
113          public void SetAssembly(string filename){
114              a = Assembly.LoadFrom(filename);
115              if(a == null) throw new PluginLoadException("Assembly "+filename+" not found or not valid");
116          }
117          
118          public Type GetFirstType(Assembly a, Type type){
119              foreach(Module mod in a.GetLoadedModules()){
120                  foreach(Type ty in mod.GetTypes()){
121                      foreach(Type intf in ty.GetInterfaces()){
122                          if(intf == type){
123                              return ty;
124                          }
125                      }
126                  }
127              }
128              return null;
129          }
130          
131          public IGameType GetClientsideInfo(){
132              Type ty = GetFirstType(a, typeof(IGameType)); 
133              if(ty == null) return null;
134              return (IGameType)a.CreateInstance(ty.FullName);
135          }
136          
137          public static PluginLoader Make(PluginInfo pi){
138              AppDomainSetup setup = new AppDomainSetup();
139              setup.ApplicationName = "Plugins";
140              setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
141              pi.domain  = AppDomain.CreateDomain("plugin", null, setup);
142              pi.domain.DomainUnload += new EventHandler(DomainUnload);
143              PluginLoader loader = (PluginLoader)pi.domain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "RedCorona.GameClient.PluginLoader");
144              //loader.Initialise();
145              return loader;
146          }
147          
148          public static void DomainUnload(object sender, EventArgs ea){
149              Console.WriteLine("Plugin domain "+sender+" unloaded!");
150          }
151          
152      }

46          public static IGameType LoadContent(String filename){
60              PluginInfo pi = new PluginInfo();
61              PluginLoader loader = PluginLoader.Make(pi);
62              loader.SetAssembly(filename);
63              return loader.GetClientsideInfo();
64          }

BobJanova wrote:

specify an Init method

BobJanova wrote:

you are going to get a runtime exception