how to inherit one form properties to another form in C#

An extended comment on SAK's remarks on using Interfaces: I am including this in "answer" form, rather than "comment" form, so I can use a little high-lighting in the writing, for emphasis.

I think your continuing exposition/advocacy of using objects/classes/forms instances cast to Interfaces as a way to partially expose/share ... to allow "access" to ... selected contents of one object/class/form by another(s) is an important technique and concept.

Where I sometimes have trouble with the way you explain it is in your use of the word "shared" or statements like "some interface known to both forms" : for example in this thread, the OP's scenario needs only one Form to implement the Interface: the second Form can declare a public instance of it without implementing it.

For an Interface to be "known" to more than one class it usually is in its own class, independent, for example, of any Form definitions. That's best practice, imho, for future code maintainability and OO structure.

Yes, there are two other ways you can define an Interface ... outside its own class ... within the scope of either a NameSpace which happens to contain a Form class definition, or even within a Form Class definition, but use of those, imho, is confusing, and potentially a source of error: if I define an interface inside the scope of Form1's class definition, only an external form, like Form2 in this case, can inherit from it !

or ... if you locate the Interface definition in the file/Namespace that happens to include a Form ... completely outside the scope of the Form's definition ... the Form in that Namespace can, indeed, inherit, from that Interface, but this is really the exact equivalent of defining the Interface in its own class.

Particularly for newcomers here, I think it's very valuable to distinguish between circumstances in which the Interface must be implemented by a class/object/form (a "special mode" of .NET C#'s Inheritance model, if you will), and circumstances in which an Interface definition can be used, and exactly when an instance of a object/class/Form must be cast to an Interface.

I would love to see you write a full-blown CP article, with code examples of course, discussing the relative merits of the strategy of using Interfaces (perhaps focusing on the use case where they must be cast to an instance of the Interface) as a way to expose controlled access, with ideas about "best practices," and scenarios in which you would, and would not, choose this practice over the other types of strategies we so often discuss here: via events; via public static classes, via the delegate-with-static-public-instance technique I show here on this thread.

Perhaps in that article you could also explain your point about the partial class definitions and how they are valuable or relate to Interfaces, which, perhaps, I've never understood, and I suspect other people do not "get," also.

Another, wider-scope, I think, issue of interest in OO design vis-a-vis Interfaces here is ... well, let me frame it with a rhetorical question: at what point when a Class needs access to almost all the Fields, Methods, whatever, of another Class does that become a scenario best implemented by refactoring ... of some form ... like: into a base class which both classes inherit from, or by creating an Interface and passing instances of that Interface ?

As I've said before, I love thinking of work other people could do :)

regards, Bill

This is a popular question on form collaboration. The most robust approach is implementing of an appropriate interface in a form class. It is especially convenient to use partial class declaration for a form. Please see my past solution for more detail: How to copy all the items between listboxes in two forms[^].

—SA

Here's a different type of solution that shares access to one-and-only-one private method in Form1 in a way it can be called from Form2.

Consider in Form1 you have a TextBox, 'textBox1:

// a delegate defines a signature for a method
public delegate void MyFunctionExposed();

// we create a public static Class-level
// instance of the Type of the delegate
public static MyFunctionExposed mfX;

// this is the private function you want
// to call from Form2
private void MyFunction()
{
    textBox1.Text = "MyFunction on Form1 called";
}

// create a new instance of Form2
Form2 f2 = new Form2();

private void Form1_Load(object sender, EventArgs e)
{
    // show Form2
    f2.Show();

    // assign MyFunction as the value of the static
    // delegate mfX
    mfX = MyFunction;
}

Now, on Form2 which has only a Button, 'button1:

private void button1_Click(object sender, EventArgs e)
{
    // the mfX delegate, ready to execute MyFunction
    // in Form1 is exposed here because it's static and public
    Form1.mfX();
}

Discussion:

1. I believe the minimal amount of "exposure" between objects in different Forms/Clases is a good thing in terms of OO design (separation of concerns). One solution above gives Form2 complete access to everything inside Form1: that will work, but is that "mixing" of total access potentially a source of confusion and errors: some think so. My nickname for solutions that provide some small class access to wide functionality in other classes ... that is not related to the purpose of the small class: "tail wags dog" code :)

2. another valid solution idea described above is provided in the idea of a common class, shared by all forms that implements data or methods needed by all or many Forms.

One strategy is to make that shared class static: there are other scenarios where that shared class must be dynamic, and there you have some interesting complications in terms of making sure ... if there's more than one instance of the shared class ... that the "correct one is being used."

And, to make it more interesting, that shared class could be both dynamic (i.e., created via 'New), and yet have certain static methods or whatever in it.

But, "one size never fits all," even though feet do stop growing after a while :)

Missing from this discussion is any idea of using interfaces, but SAK, I am sure, will take care of that. And ... uh oh ... we left out using Events !

Solution 2 is correct, however, if the method in Form1 is shared you should consider implementing a common class that can be shared between all forms. An separate assembly will provide you with easier maintenance and extensibility.

If I understand correctly all you will need to do is create an instance of the fist form in the second form or pass a reference of the first form to the second form.

//To create instance of second form inside first form do this i.e.
Form2 form2 = new Form2();
form2.MyFunction();

//to pass a reference to first form into the second form i.e.
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        Form2 form2 = new Form2(this);
    }

    public MyFunction()
    {
        // do stuff
    }
}

public partial class Form2 : Form
{
    Form1 mainForm;

    public Form2(Form1 mainForm)
    {
        InitializeComponent();

        this.mainForm = mainForm;
        // call form1 MyFunction()
        mainForm.MyFunction();
    }
}