C#

public class Example
{
    // example of zero parameter function call
    public string GetFileName()
    {
            Assembly assem = Assembly.LoadFrom(@"C:\Test.dll"); // load the assembly
            Type typClsX = assem.GetType("Test.Class1", true);  // create  the object type
            object oClsX = Activator.CreateInstance(typClsX);   // create the instance
              // Function name and parameter list (in this case empty param list)
            MethodInfo miGncn = typClsX.GetMethod("ReturnFileName", new System.Type[0]);
              // invoke the function
            string intAddFunc = (string)miGncn.Invoke(oClsX,null);
              //  the result
            return intAddFunc;
    }

    // example of parameter list function call
    public int DoAdd(int x, int y)
    {

            object[] Parms = {x,y};  // parameter list
            Assembly assem = Assembly.LoadFrom(@"C:\BasicMath.dll"); // load the dll assembly
            Type typClsX = assem.GetType("BasicMath.Operations", true); // FQN
            object oClsX = Activator.CreateInstance(typClsX);       // create the instance
            MethodInfo miGncn = typClsX.GetMethod("DoAdd");         // retreive the function
            int intAddFunc = (int)miGncn.Invoke(oClsX, Parms);      //  invoke the with param list
            return intAddFunc;
    }
}

Mark Churchill wrote:

Just checking the obvious, but you do realise that bool? is shorthand for the struct System.Nullable< bool> yeah?

Mark Churchill wrote:

The complier is probably selecting the AddValue(string, bool) overload, and putting a bool in the ourput stream.

Mark Churchill wrote:

I would suggest that info.GetValue(..., typeof(object)) is actually returning a boxed bool, which in the watch window looks a lot like a string (as .ToString() is called). You can't cast directly from a boxed boolean to a bool? - you will have to go with new bool?(GetValue(bool)).

[TestFixture]
public class RandomTests
{
    [Serializable]
    public class Foo : ISerializable
    {
        public bool? bn = true;
        public bool? bt = null;
        public bool? bf = null;

        public Foo()
        {
            bn = null;
            bt = true;
            bf = false;
        }

        protected Foo(SerializationInfo info, StreamingContext context)
        {
            bn = (bool?)info.GetValue("bn", typeof(bool?));
            bt = (bool?)info.GetValue("bt", typeof(bool?));
            bf = (bool?)info.GetValue("bf", typeof(bool?));
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("bn", bn);
            info.AddValue("bt", bt);
            info.AddValue("bf", bf);
        }
    }
    private SerializationInfo _info;
    private Foo foo;

    [TestFixtureSetUp]
    public void Setup()
    {
        var stream = new MemoryStream();

        var formatter = new BinaryFormatter();
        formatter.Serialize(stream, new Foo());

        stream.Seek(0, SeekOrigin.Begin);

        foo = (Foo) formatter.Deserialize(stream);
    }

    [Test]
    public void BoolFalse()
    {
        Assert.IsFalse(foo.bf.Value);
    }
    [Test]
    public void BoolTrue()
    {
        Assert.IsTrue(foo.bt.Value);
    }
    [Test]
    public void BoolNull()
    {
        Assert.IsNull(foo.bn);
    }
}

private System.Data.SqlTypes.SqlInt64 nextTaskRef()
{ 
        try
        {
                string getTaskRef = @"SELECT MAX([taskID_PK]) FROM [teamwiki].[dbo].[task];";
                SqlCommand getTaskRefSQL = new SqlCommand(getTaskRef, conAppDB);

                object rawValue = getTaskRefSQL.ExecuteScalar();
                if (rawValue != DBNull.Value) {
                    return (System.Data.SqlTypes.SqlInt64) rawValue; //if you return from this
                                                                        // point your finally block will not 
                                                                        // get executed, and becomes unreachable code
                }
        }
        catch (Exception ex) {
            throw ex; //once you throw an exception it comes out of catch block, so following code is unreachable
            return 0; //tried to return null as well unsuccessfullly
                      //this indicates an error condition 

        }
        finally {
            conAppDB.Close();
        }
        return 0; // should have return here as well, at instancecs when it reaches this point
                     // before quiting it sholud return something
    }

private System.Data.SqlTypes.SqlInt64 nextTaskRef()
{ 
        object rawValue;
        try
        {
                string getTaskRef = @"SELECT MAX([taskID_PK]) FROM [teamwiki].[dbo].[task];";
                SqlCommand getTaskRefSQL = new SqlCommand(getTaskRef, conAppDB);
                rawValue = getTaskRefSQL.ExecuteScalar();
        }
        catch (Exception ex) {
            throw ex;
        }
        finally {
            conAppDB.Close();
        }
        if (rawValue != DBNull.Value) {
             return (System.Data.SqlTypes.SqlInt64) rawValue;
        }
        return 0;
}

return (System.Data.SqlTypes.SqlInt64) rawValue;

if (rawValue != DBNull.Value) {
   return (System.Data.SqlTypes.SqlInt64) rawValue;
}
else {
   return 0;
}

private static readonly int MinValue = 0;
private static readonly int MaxValue = 100;
int textBox1Value;
int textBox2Value;
bool textBox1Valid;
bool textBox2Valid;
private void textBox1_Validating(object sender, CancelEventArgs e)
{
    if (!ValidateTextBoxes() && !textBox1Valid)
    {
        e.Cancel = true;
        textBox1.SelectAll();
    }
}
private void textBox2_Validating(object sender, CancelEventArgs e)
{
    if (!ValidateTextBoxes() && !textBox2Valid)
    {
        e.Cancel = true;
        textBox2.SelectAll();
    }
}
private bool ValidateTextBoxes()
{
    textBox1Valid = int.TryParse(textBox1.Text, out textBox1Value);
    textBox2Valid = int.TryParse(textBox2.Text, out textBox2Value);
    if (textBox1Valid)
        textBox1Valid = textBox1Value >= MinValue && textBox1Value <= MaxValue;
    if (textBox2Valid)
        textBox2Valid = textBox2Value >= MinValue && textBox2Value <= MaxValue;
    SetResultLabel(textBox1Valid && textBox2Valid);
    return textBox1Valid && textBox2Valid;
}
private void SetResultLabel(bool validated)
{
    if (validated)
        label1.Text = string.Format("{0}:{1}", textBox1Value, textBox2Value);
    else
        label1.Text = string.Empty;
}