Blog Archives

Non-static method requires a target

In my specific situation where I received this error, I was able to resolve it by simply changing “null” to the object containing the method which needed to be call.

This error indicates a use of reflections that can easily be confusing, but is very simple to resolve.

The specific resolution in the (StackOverflow) example in the referenced link below did not apply to my situation, but helped me quickly understand what caused the error and come to quick resolution by simply reading through the responses.

Example code from reference below:

public static T Test<T>(MyClass myClass) where T : MyClass2, new()
{
    var result = new T();
    //...
}

For specific code example where I encountered this message and how I was able to resolve, see the snippet below or my full post Call Parent Page from User Control.

Quick comparison where I encountered the error:

if (mi!=null) mi.Invoke(null, new Object[] {sender,e }); //throws indicated error

if (mi!=null) mi.Invoke(this.Page, new Object[] {sender,e }); //runs through clean

References
“Call Parent Page from User Control”, https://ronniediaz.com/2011/07/15/call-parent-page-from-user-control/
StackOverflow, http://stackoverflow.com/questions/3577407/non-static-method-requires-a-target-in-propertyinfo-setvalue

Advertisements

call parent page from user control to invoke page methods

To illustrate how we will accomplish this using Reflections, we will be using repeater in a user control within a page.

Your repeater loads data easily within the user control code behind, but you want to utilize the “ItemCommand” event of the repeater to update some values on the page page.

Here’s how this can work:

Parent Page:

//the name doesn't have to match the corresponding method on user control but makes code more readable
    public void rptRepeaterName_ItemCommand(object sender, RepeaterCommandEventArgs e)
    {

        try
        {
            if (e.CommandName == "commandname")
            {
               //do some work on data then call update on parent page to reload data and show within a modal

                ParentPage_UpdatePanel.Update();
                ParentPage_ModalPopup.Show();

            }
        }
        catch (Exception ex)
        { 
//do something
            throw new ApplicationException(ex.ToString());
        }

    }

User Control:

    protected void rptRepeaterName_ItemCommand(object sender, RepeaterCommandEventArgs e)
    {
        MethodInfo mi = this.Page.GetType().GetMethod("rptRepeaterName_ItemCommand", BindingFlags.Public | BindingFlags.Instance);

//note we specify parent page as the object and pass in a new object representing our repeater and carrying its parameters
        if (mi!=null) mi.Invoke(this.Page, new Object[] {sender,e });

    }

Voila! Behold the power of Reflections! 8)

In particular, one of the references below (thanks Bruce Barker!) helped me come to this answer, however, the exact code he presents will result in a “Non-static method requires a target” error.

To avoid this error, make sure you always pass in the object when invoking a method that is non-static (within a class that is instantiated).

To learn more about reflections and how it works search my blog for other examples, and visit MSDN for a good overview.

References
Velocity Reviews, http://www.velocityreviews.com/forums/t71075-invoke-methods-on-the-parent-page-from-the-user-control.html
Reflection Overview (MSDN), http://msdn.microsoft.com/en-us/library/f7ykdhsy%28v=vs.71%29.aspx

C# .Net Clone and Copy Objects using Extension Methods

One of my earliest blog articles – Clone Objects in .Net Using Reflections – briefly discusses shallow and deep object copying and cloning.

For more info. on the semantics and what these terms really mean, see referenced wikipedia article.

You may or may not already be familiar with cloning native objects in .Net, such as the datatable. However, for custom classes, you are left to your own creations.

With the advent of extension methods in .Net, the functionality to copy objects can now be moved from static helper classes to inheritable extension methods and has new life and renewed usability. See code snippet below.

Thanks goes to R. Prestol for this one.

public static T GetCopy<T>(this T S)
    {
        T newObj = Activator.CreateInstance<T>();

        foreach (PropertyInfo i in newObj.GetType().GetProperties())
        {

//"EntitySet" is specific to link and this conditional logic is optional/can be ignored
            if (i.CanWrite && i.PropertyType.Name.Contains("EntitySet") == false)
            {
                object value = S.GetType().GetProperty(i.Name).GetValue(S, null);
                i.SetValue(newObj, value, null);           
            }
        }

        return newObj;
}

References
MSDN (Extension Methods), http://msdn.microsoft.com/en-us/library/bb383977.aspx
“Clone Objects in .Net Using Reflections”, https://ronniediaz.com/2010/03/02/clone-objects-in-net-using-reflections/
Wikipedia, “Object Copy”, http://en.wikipedia.org/wiki/Object_copy