C#

name = System.IO.Path.GetFileNameWithoutExtension ( Filename ) ;

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

assm = System.AppDomain.CreateDomain ( name ).
    Load ( System.IO.File.ReadAllBytes ( Filename ) ) ;

private string myProperty = "Default Value";

public string MyProperty{
get{return myProperty;}
set{myProperty = value;}//use the word 'value' here, do not substitute
}

public void SetValues(string val1, string val2, string val3)
{
     MyVal1 = val1;
     //etc.
}

public static string Val1 = "My Val 1";

//inside form2
MyVal1 = Form1.Val1;

using System;
using System.Windows.Forms;

namespace ValuePassing
{
    public class FormParent : Form
    {
        public FormParent()
        {
            Shown += new EventHandler(FormParent_Shown);
        }

        void FormParent_Shown(object sender, EventArgs e)
        {
            FormChild formChild = new FormChild();
            formChild.ValueChanged += new EventHandler<ValueChangedEventArgs>(formChild_ValueChanged);
            formChild.VisibleToParentMethod(100);
            formChild.VisibleToParentProperty = 200;
        }

        void formChild_ValueChanged(object sender, ValueChangedEventArgs e)
        {
            Text = (string.Format("Value = {0}", e.Value));
        }
    }

    public class FormChild : Form
    {
        public event EventHandler<ValueChangedEventArgs> ValueChanged;

        private int visibleToParentValue;

        public int VisibleToParentProperty
        {
            get { return visibleToParentValue; }
            set
            {
                MessageBox.Show("Property");
                SetVisibleToParentValue(value);
            }
        }

        public void VisibleToParentMethod(int value)
        {
            MessageBox.Show("Method");
            SetVisibleToParentValue(value);
        }

        private void SetVisibleToParentValue(int value)
        {
            if (visibleToParentValue != value)
            {
                visibleToParentValue = value;
                OnVisibleToParentValueChanged(new ValueChangedEventArgs(value));
            }
        }

        protected virtual void OnVisibleToParentValueChanged(ValueChangedEventArgs e)
        {
            EventHandler<ValueChangedEventArgs> eh = ValueChanged;
            if (eh != null)
                eh(this, e);
        }
    }

    public class ValueChangedEventArgs : EventArgs
    {
        public ValueChangedEventArgs(int value)
        {
            Value = value;
        }
        public int Value
        {
            get;
            private set;
        }
    }
}