How to access MainWindow's variables from second Window - c#

Is there another way to access MainWindow's public variables than :
MainWindow mainWindow = Application.Current.Windows.OfType<MainWindow>().FirstOrDefault();
mainWindow.variable....
this work fine, but I'm creating a WPF application and integrating a USB Webcam to my project and using this code above to access MainWindow's variables. This causes some problems like program is still running when I close MainWindow and camera won't stop.
Any suggestions?

This is an over simplified example for what i wrote in comments(you really should look at mvvm the example below is not mvvm).
public class SelectedIndexData
{
public int SelectedIndex { get; set; }
}
public partial class MainWindow : Window
{
private readonly SelectedIndexData _selectedIndexData = new SelectedIndexData();
public MainWindow()
{
InitializeComponent();
}
private void ComboBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
_selectedIndexData.SelectedIndex = ComboBox.SelectedIndex;
}
private void ShowChildWindow(object sender, RoutedEventArgs e)
{
new ChildWindow(_selectedIndexData).Show();
}
}
public partial class ChildWindow : Window
{
private SelectedIndexData _selectedIndexData;
public ChildWindow(SelectedIndexData selectedIndexData)
{
InitializeComponent();
_selectedIndexData = selectedIndexData; // do whatever you want with your data here
}
}

This approach work also if you are developing a dll (you can't tell the same about Application.Current.MainWindow, which is clearer then your attempt anyways)
DependencyObject ucParent = this.Parent;
while (!(ucParent is MainWindow))
{
ucParent = LogicalTreeHelper.GetParent(ucParent);
}
mainview = ucParent as MainWindow;
You can pack this inside a method, save the variables that you need and you shouldn't have problems

To make sure you application shuts down when MainWindow is closed:
public MainWindow()
{
InitializeComponent();
this.Closing += (sender, args) => Application.Current.Shutdown();
}

Related

c# between windows form send data [duplicate]

In this example, MainWindow has a button that opens Window2.
Window2 has a button that writes "Hello, World!" to MainWindow textblock.
Project source: https://www.dropbox.com/s/jegeguhycs1mewu/PassData.zip?dl=0
What is the proper way to pass data from Window2 to MainWindow?
private MainWindow mainwindow;
public MainWindow mainwindow { get; private set; }
public Window MainWindow { get; set; }
private object mainwindow { get; private set; };
private MainWindow mainwindow = ((MainWindow)System.Windows.Application.Current.MainWindow);
this.mainwindow = mainwindow;
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
// Open Window 2
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
Window2 window2 = new Window2(this);
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
}
Window 2
public partial class Window2 : Window
{
private MainWindow mainwindow;
public Window2(MainWindow mainwindow)
{
InitializeComponent();
this.mainwindow = mainwindow;
}
// Write Message to MainWindow
private void buttonMessage_Click(object sender, RoutedEventArgs e)
{
mainwindow.textBlockMessage.Text = "Hello, world!";
}
}
The 'proper' way usually depends on what your needs and circumstances are. But in general, using a delegate to pass data between windows is a common and standard practice.
Lets say the data you want to pass is a string. In your Main window, you want to create a delegate that lets you pass a string. Then you create an instance of that delegate type and subscribe a method that matches. Then when you open your secondary window, you pass that delegate to your secondary window.
public delegate void DataTransfer(string data);
public partial class MainWindow : Window
{
public DataTransfer transferDelegate;
public MainWindow()
{
InitializeComponent();
transferDelegate += new DataTransfer(DataMethod);
}
public void DataMethod(string data)
{
// Do what you want with your data.
}
private void button1_Click(object sender, EventArgs e)
{
Window2 win = new Window2(transferDelegate);
win.Show();
}
}
Now, when you invoke that delegate in your secondary window, the DataMethod() of your Form1 gets called, and so you can pass information between windows.
Your secondary window implementation should look like this:
public partial class Window2 : Window
{
DataTransfer transferDel;
public Window2(DataTransfer del)
{
InitializeComponent();
transferDel = del;
}
private void button1_Click(object sender, EventArgs e)
{
string data = "Hello, World!"; // Your string data to pass.
transferDel.Invoke(data);
}
}
As you can see, when you invoke the delegate that was passed, it calls the corresponding method in your main program.
One stand out advantage of this method is that you don't need to pass an instance of MainWindow to your Window2, you simply use delegates and subscribed methods to pass data between the two instances of windows.
The answer you're looking for is very implementation-based and depends heavily on what you want Window2 as a class to do.
private MainWindow mainwindow;
This is acceptable.
public MainWindow mainwindow { get; private set; }
This would work but doesn't respect naming conventions because it's a property. Usually you'd use this for encapsulation of a field or for easy access to a computed value.
public Window MainWindow { get; set; }
This is not acceptable in your context because Window does not contain a textBlockMessage.
private object mainwindow { get; private set; };
This also wouldn't work for the same reason as above.
private MainWindow mainwindow = ((MainWindow)System.Windows.Application.Current.MainWindow);
This would work and would even let you not keep a field for the reference to the MainWindow instance in your Window2 instances. Still needs to get that MainWindow everytime you click the button however.
Another interesting way to do what you're doing however is to simply pass the handler to the child windows at instanciation:
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
// Open Window 2
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
Window2 window2 = new Window2(); // No need to give a reference to the child window anymore
window2.setClickHandler((obj, ev) => {
textBlockMessage.Text = "Hello, world!"; // Direct access to the textblock.
});
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
}
Window2
public partial class Window2 : Window
{
public Window2()
{
InitializeComponent();
}
public void setClickHandler(RoutedEventHandler handler)
{
// The handler is given to the click event.
buttonMessage.Click -= handler;
buttonMessage.Click += handler;
}
}
And with that your Window2 class has no need to know MainWindow.
You could declare a delegate in Window 2 and pass a function that can be executed when the button is pressed in window 2.
public delegate void SendMessage(string Message);
public SendMessage mainWindowDel = null;
Make your constructor that accepts the delegate
public Window2(SendMessage del)
{
mainWindowDel = del;
}
create window 2 by passing a function as the parameter
public void showMessage(string Message)
{
if(!string.IsNullOrWhiteSpace(Message))
textBlockMessage.Text = Message;
}
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
// Open Window 2
//Window2 window2 = new Window2(this);
Window2 window2 = new Window2(showMessage);
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
call the delegate when they press the button
// Write Message to MainWindow
private void buttonMessage_Click(object sender, RoutedEventArgs e)
{
mainWindowDel("Hello, world!");
}
You could probably set the datacontext of the MainWindow to an object that you could also pass to Window2 when it's created and set it's datacontext to the same object.
In that object could create a string property that could be used in both windows. And if you implement the INotifyPropertyChanged interface both windows would know when that string is updated.
Another Approach
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private bool DisplayText(string displayText)
{
txt_Main.Text = displayText;
return true;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Window2 win2 = new Window2(DisplayText);
win2.ShowDialog();
}
}
Window2
public partial class Window2 : Window
{
private Func<string, bool> mainWindowMethod;
public Window2(Func<string, bool> displayMethod)
{
InitializeComponent();
this.mainWindowMethod = displayMethod;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
this.mainWindowMethod("Hello World");
}
}

Pass Data from Child Window to MainWindow TextBlock

In this example, MainWindow has a button that opens Window2.
Window2 has a button that writes "Hello, World!" to MainWindow textblock.
Project source: https://www.dropbox.com/s/jegeguhycs1mewu/PassData.zip?dl=0
What is the proper way to pass data from Window2 to MainWindow?
private MainWindow mainwindow;
public MainWindow mainwindow { get; private set; }
public Window MainWindow { get; set; }
private object mainwindow { get; private set; };
private MainWindow mainwindow = ((MainWindow)System.Windows.Application.Current.MainWindow);
this.mainwindow = mainwindow;
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
// Open Window 2
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
Window2 window2 = new Window2(this);
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
}
Window 2
public partial class Window2 : Window
{
private MainWindow mainwindow;
public Window2(MainWindow mainwindow)
{
InitializeComponent();
this.mainwindow = mainwindow;
}
// Write Message to MainWindow
private void buttonMessage_Click(object sender, RoutedEventArgs e)
{
mainwindow.textBlockMessage.Text = "Hello, world!";
}
}
The 'proper' way usually depends on what your needs and circumstances are. But in general, using a delegate to pass data between windows is a common and standard practice.
Lets say the data you want to pass is a string. In your Main window, you want to create a delegate that lets you pass a string. Then you create an instance of that delegate type and subscribe a method that matches. Then when you open your secondary window, you pass that delegate to your secondary window.
public delegate void DataTransfer(string data);
public partial class MainWindow : Window
{
public DataTransfer transferDelegate;
public MainWindow()
{
InitializeComponent();
transferDelegate += new DataTransfer(DataMethod);
}
public void DataMethod(string data)
{
// Do what you want with your data.
}
private void button1_Click(object sender, EventArgs e)
{
Window2 win = new Window2(transferDelegate);
win.Show();
}
}
Now, when you invoke that delegate in your secondary window, the DataMethod() of your Form1 gets called, and so you can pass information between windows.
Your secondary window implementation should look like this:
public partial class Window2 : Window
{
DataTransfer transferDel;
public Window2(DataTransfer del)
{
InitializeComponent();
transferDel = del;
}
private void button1_Click(object sender, EventArgs e)
{
string data = "Hello, World!"; // Your string data to pass.
transferDel.Invoke(data);
}
}
As you can see, when you invoke the delegate that was passed, it calls the corresponding method in your main program.
One stand out advantage of this method is that you don't need to pass an instance of MainWindow to your Window2, you simply use delegates and subscribed methods to pass data between the two instances of windows.
The answer you're looking for is very implementation-based and depends heavily on what you want Window2 as a class to do.
private MainWindow mainwindow;
This is acceptable.
public MainWindow mainwindow { get; private set; }
This would work but doesn't respect naming conventions because it's a property. Usually you'd use this for encapsulation of a field or for easy access to a computed value.
public Window MainWindow { get; set; }
This is not acceptable in your context because Window does not contain a textBlockMessage.
private object mainwindow { get; private set; };
This also wouldn't work for the same reason as above.
private MainWindow mainwindow = ((MainWindow)System.Windows.Application.Current.MainWindow);
This would work and would even let you not keep a field for the reference to the MainWindow instance in your Window2 instances. Still needs to get that MainWindow everytime you click the button however.
Another interesting way to do what you're doing however is to simply pass the handler to the child windows at instanciation:
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
// Open Window 2
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
Window2 window2 = new Window2(); // No need to give a reference to the child window anymore
window2.setClickHandler((obj, ev) => {
textBlockMessage.Text = "Hello, world!"; // Direct access to the textblock.
});
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
}
Window2
public partial class Window2 : Window
{
public Window2()
{
InitializeComponent();
}
public void setClickHandler(RoutedEventHandler handler)
{
// The handler is given to the click event.
buttonMessage.Click -= handler;
buttonMessage.Click += handler;
}
}
And with that your Window2 class has no need to know MainWindow.
You could declare a delegate in Window 2 and pass a function that can be executed when the button is pressed in window 2.
public delegate void SendMessage(string Message);
public SendMessage mainWindowDel = null;
Make your constructor that accepts the delegate
public Window2(SendMessage del)
{
mainWindowDel = del;
}
create window 2 by passing a function as the parameter
public void showMessage(string Message)
{
if(!string.IsNullOrWhiteSpace(Message))
textBlockMessage.Text = Message;
}
private void buttonWindow2_Click(object sender, RoutedEventArgs e)
{
// Open Window 2
//Window2 window2 = new Window2(this);
Window2 window2 = new Window2(showMessage);
window2.Left = Math.Max(this.Left - window2.Width, 0);
window2.Top = Math.Max(this.Top - 0, 0);
window2.ShowDialog();
}
call the delegate when they press the button
// Write Message to MainWindow
private void buttonMessage_Click(object sender, RoutedEventArgs e)
{
mainWindowDel("Hello, world!");
}
You could probably set the datacontext of the MainWindow to an object that you could also pass to Window2 when it's created and set it's datacontext to the same object.
In that object could create a string property that could be used in both windows. And if you implement the INotifyPropertyChanged interface both windows would know when that string is updated.
Another Approach
MainWindow
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private bool DisplayText(string displayText)
{
txt_Main.Text = displayText;
return true;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Window2 win2 = new Window2(DisplayText);
win2.ShowDialog();
}
}
Window2
public partial class Window2 : Window
{
private Func<string, bool> mainWindowMethod;
public Window2(Func<string, bool> displayMethod)
{
InitializeComponent();
this.mainWindowMethod = displayMethod;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
this.mainWindowMethod("Hello World");
}
}

how to access mainwindow from another class?

I as the title says. I want to be able to change the GUI mainwindow from other classes. When i have all methods in the mainwindow class everything workes fine. But when i use another class in same namespace it doesn't work. My code compiles but when i click on button nothing happens.
class w_Kcal
{
MainWindow mw;
public w_Kcal(MainWindow mw)
{
this.mw = mw;
mw.maintenanceButton.Click += MaintenanceButton_Click;
}
public void MaintenanceButton_Click(object sender, RoutedEventArgs e)
{
mw.maintenanceBox.Visibility = Visibility.Visible;
mw.maintenanceOKBtn.Visibility = Visibility.Visible;
}
}
Mainwindow:
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
}
It happens because you do not instantiate w_Kcal anywhere. Create this class in main window code and it should work:
public partial class MainWindow : Window
{
private w_Kcal helper;
public MainWindow()
{
InitializeComponent();
helper = new w_Kcal(this);
}
}
Hope this helps

How do I open window inside another window after

I have a mainwindown and I want to open a window inside that stays on top of it. But it seems like the window I want inside is opened before the mainwindow opens.
To solve this I need to open the window after initializecomponent of the mainwindow?
public partial class MainWindow : Window
{
public MainWindow ()
{
InitializeComponent();
OpenProjectsView();
}
private void OpenProjectsView()
{
ProjectsView projectWindow= new ProjectsView();
projectWindow.Owner = this;
projectWindow.ShowDialog();
}
}
Call OpenProjectsView( ) in Form.Activated event.
private void MainWindow_Activated(object sender, System.EventArgs e)
{
OpenProjectsView();
}
try this code
projectWindow.IsMdiContainer = True;
projectWindow.MdiParent = this;
projectWindow.Show();
Try this. It will launch your window after your main window is rendered.
public MainWindow()
{
InitializeComponent();
this.ContentRendered+= Window_ContentRendered;
}
private void Window_ContentRendered(object sender, RoutedEventArgs e)
{
OpenProjectsView();
}
public partial class MainWindow : Window
{
public MainWindow ()
{
InitializeComponent();
OpenProjectsView();
}
private void OpenProjectsView()
{
ProjectsView projectWindow= new ProjectsView();
projectWindow.Owner = this;
projectWindow.TopMost = true;
projectWindow.Show();
}
}
This will make the second window sit on top of the first, but because you create and show it during your parent window constructor, it will always appear (get instantiated) before your parent window.
This method allows that to happen, whilst you can still interact with both windows (Show() rather than ShowDialog()).
As others have mentioned, you can instantiate your window in an event, rather than the constructor, but that depends on exactly what you need ... your question is a little ambiguous! :O)

WPF call method from MainWindow not working

I have the following classes:
MainWindow:
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
MainMenu mainMenu = new MainMenu(this);
menuFrame.Navigate(mainMenu);
UserPage userP = new UserPage();
contentFrame.Navigate(userP);
}
public void LoadAPage(Page page)
{
contentFrame.Navigate(page);
}
}
MainMenu:
public partial class MainMenu : Window
{
private Window switchPage;
public MainMenu(MainWindow mainP)
{
Window mainWindow = mainP;
InitializeComponent();
switchPage = mainP;
}
private void btn_navigate_user(object sender, EventArgs e)
{
UserPage userP = new UserPage(ServiceLogic);
//switchPage = Window.GetWindow(PageSwitcher);
//switchPage.LoadAPage(new UserPage());
}
As you can see, I'm trying to use the LoadAPage-method from the MainWindow. The MainMenu and UserPage are childs from the MainWindow. The problem is, no matter what I try, I cannot reach the LoadAPage method. I've tried setting the Owner but that doesn't work. When trying mainMenu.Owner = this;, Visual Studio says Mainmenu does not contain a definition for 'Owner``. When I give the parent class as a parameter to the child class, there are no errors but the methodLoadAPage` is unknown there.
What am I doing wrong? How should I solve this?
EDIT: Changing MainMenu to a Window instead of UserControl makes me able to set the Owner. Still, I can't reach the method.
What a mess :) Try this
private MainWindow switchPage;
public MainMenu(MainWindow mainP)
{
InitializeComponent();
switchPage = mainP;
}
private void btn_navigate_user(object sender, EventArgs e)
{
UserPage userP = new UserPage(ServiceLogic);
switchPage.LoadAPage(userP);
}
However i think you ll be better off using events, instead of passing your window object to its childs.

Categories

Resources