C#中 对不同类的实例进行批量操作

Question

已知：
public Hashtable ht=new Hashtable();
public class class1
{
public string name="c1";
}
public class class2
{
public string name="c2";
}
public class class3
{
public string name="c3";
}
// .
// .
// .
//class1,class2,class3……classN 这些类可以看成是一些写好forms窗体类
public class classN
{
public string name="cN";
} public class change
{
public change()
{
}
public void rename(类型？ ci,string stri)  //？？？这个地方怎么定义参数ci？？？
{
ci.name=stri;
}
}想要的操作：//对N个类进行判断操作。如果类被实例化一次，直接修改name；如果没有，则实例化，然后修改name if (ht中是否记录了对象c1的ID) { c1.name="c11";}
else { c1=new class1(); c1.name="c11";添加c1的ID到ht中 }
if (ht中是否记录了对象c2的ID) { c2.name="c22";}
else { c2=new class2(); c1.name="c22"; 添加c2的ID到ht中 }
if (ht中是否记录了对象c3的ID) { c3.name="c33";}
else { c3=new class3(); c1.name="c33"; 添加c3的ID到ht中 }

// .
// .
// .
if (ht中是否记录了对象cN的ID) { cN.name="cNN";}
else { cN=new classN(); c1.name="cNN"; 添加cN的ID到ht中 }最终需要的类：（转化为批量操作：） public void main()
{
change change1=new change(); change1.rename(c2,c2.name+"2")
change1.rename(c5,c5.name+"5")
change1.rename(c99,c99.name+"99")
}说明
上面那些代码可能语法不对，请高手自己改成C#下的。只希望能看懂我的问题所在。假设有100个窗体类class1,class2,class3 ... class100，不需要实例化所有的窗体，而是需要对某个窗体操作时，再判断窗体是否被实例化启动了，然后再修改 所实例化的窗体的内容。而且修改时，必须把窗体类当作一个变量方便批量操作。因此
1 需要定义一个 change类，控制所有的窗体情况。怎么写好这个change类？？？
2 或者怎么可以把窗体类class1,class2,class....N这些当作一个变量？

Answer 1

change（class[] objclass）
{
}
或者
change（params class objclass）
{
}

Answer 2

直接拿原例来说吧： frm1 f1= new frm1(); 
f1.Load += new EventHandler(form_Load); 
f1.Closed += new EventHandler(form_Closed); 
f1.Show(); frm2 f2= new frm2(); 
f2.Load += new EventHandler(form_Load); 
f2.Closed += new EventHandler(form_Closed); 
f2.Show(); frmN fN= new frmN(); 
fN.Load += new EventHandler(form_Load); 
fN.Closed += new EventHandler(form_Closed); 
fN.Show(); 能不能编写个函数供调用：如下这样？
public void bindForm(System.Windows.Forms fi) 
{ 
frmi fi= new frmi(); 
fi.Load += new EventHandler(form_Load); 
fi.Closed += new EventHandler(form_Closed); 
fi.Show(); 
} 
反正就是不知道如何写参数fi的类型，因为frm1,frm2,frm3等等这些类同属于一个命名空间，但父类forms也不对！ 
怎么可以把frmi这个类，转化为一个可调用的参数

Answer 3

public   void   bindForm(System.Windows.Forms   fi)   
{   
frmi   fi=   new   frmi();   
fi.Load   +=   new   EventHandler(form_Load);   
fi.Closed   +=   new   EventHandler(form_Closed);   
fi.Show();   
}
//======
上面两次定义的fi

Answer 4

另外窗口的基类是  Form 不是Forms

Answer 5

谢谢楼上各位哥们，可能我没表达好问题吧我就是想写一个类或者函数，监管所有窗体类的情况。
有个全局变量hashtable记录了所有窗体的情况。所以给frmi绑同样的方法来访问hashtable判断该窗体的情况

Answer 6

楼主要这样的？private CreateForm(Type FormType)
{
   Form f = (Form)Activator.CreateInstance(FormType);
   f.Load += new EventHandler(form_Load);       
   f.Closed += new EventHandler(form_Closed);       
   f.Show(); 
}调用的时候：
CreateForm(typeof(Form1))

Answer 7

把公共属性和方法抽象到一个接口或基类里然后让你的那些对象都从基类或接口派生这样你的Hashtable里放的就是基类或接口类型的引用使用的时候也是转化为基类或接口类型来操作对象.建议楼主去补习一下面向对象里的多态的概念.

Answer 8

非常感谢楼上各位的参与，感谢yzxdc 给的例子，但我还是想不出好方法来解决我的问题
面对高手们，我也不拐弯了。直接把问题摆出来吧：
namespace ManufactureSystem
{
  public class frmMainmenu : System.Windows.Forms.Form
{
//....
//100个按钮,分别打开100个窗体，对应的每个窗体如下操作：
//***********************************
private static Form1 f1;
private bool isForm1Closed = true;
private void btnForm1_Click(object sender, System.EventArgs e)
{
if(isForm1Closed)
{
//this.mlineCD,this.mlineName,this.mUserCD,this.mUserName
f1 = new Form1();
f1.Load += new EventHandler(f1_Load);
f1.Closed += new EventHandler(f1_Closed);
f1.Show();
this.WindowState = FormWindowState.Minimized;
}
else
{
f1.WindowState = FormWindowState.Normal;
f1.Activate();
this.WindowState = FormWindowState.Minimized;
}
}
private void f1_Load(object sender, EventArgs e)
{
isForm1Closed = false;
}
private void f1_Closed(object sender, EventArgs e)
{
isForm1Closed = true;
this.WindowState = FormWindowState.Normal;
}
}
//***********************************//100个窗体
 public class Form1 : System.Windows.Forms.Form
{
//....
}
  public class Form2 : System.Windows.Forms.Form
{
//....
}
 //...
   public class Form100 : System.Windows.Forms.Form
{
//....
}
}
要想实现100个按钮分别对应100个窗体的话，要复制100遍上面**之间类似的代码，能否给个方法或者类实现操作？
1 建立一个全局变量hashtable 记录所有窗体的情况，也就是把private bool isForm1Closed，isForm2Closed...这些放到hashtable里
2 来一个方法实现对所有button绑定click事件比如private void btnForm1_Click(object sender, System.EventArgs e)
{
CheckForms("Form1");
}
private void CheckForms(string FormClassName)
{
原文中**号之间的那些操作
}补充：
1 是否该给所有的form绑定相同的load，和closed事件？只不过修改下hashtable中关于该窗体的状态。
2 多态没法实现，是不是用 反射机制相关的技术来实现？

Answer 9

将一百个窗口类型和一百个按钮绑定的代码是少不了的，建议使用Tag，比如
btnForm1.tag = typeof(Form1);
然后所有按钮相应同一个事件
Hashtable Forms = new Hashtable;
private   void   btnForm_Click(object   sender,   System.EventArgs   e) 
{ 
    Type formtype = (Type)((Button)sender).tag
    Form f = null;
    if(Forms[formtype] != null)
        f = (Form)Forms[formtype]
    if(f == null || f.Visible = false) 
    { 
      f = (Form)Activator.CreateInstance(formtype); 
      f.Load += new   EventHandler(form_Load);               
      f.Closed += new   EventHandler(form_Closed);
      Forms[formtype] = f;               
      f.Show();  
      this.WindowState = FormWindowState.Minimized;   }
   else 
   { 
      f.WindowState = FormWindowState.Normal; 
      f.Activate(); 
      this.WindowState = FormWindowState.Minimized; 
   } 
} 
说真的，我建议你这一百个窗口都继承统一的基类，这样会好很多。

Answer 10

这样的话form_Load其实是不需要的，form_Closed可以释放一下窗口引用
private void form_Closed(object   sender,   EventArgs   e) 
{ 
    Forms.Remove(object.GetType());
    this.WindowState   =   FormWindowState.Normal; 
} 

Answer 11

忽然发现窗口隐藏判断都是不需要的，基本上整理成下面这样就可以了btnForm1.tag  = typeof(Form1); 
....然后所有按钮相应同一个事件 
Hashtable Forms = new Hashtable(); 
private void btnForm_Click(object sender,System.EventArgs e)   
{   
   Type formtype = (Type)((Button)sender).tag 
   Form f = (Form)Forms[formtype] 
   if(f == null)   
   {   
       f = (Form)Activator.CreateInstance(formtype);   
       f.Closed += new EventHandler(form_Closed); 
       Forms[formtype] = f;                               
       f.Show();            
   } 
   else   
   {   
       f.WindowState = FormWindowState.Normal;   
       f.Activate();   
   }
   this.WindowState = FormWindowState.Minimized;   
}   private void form_Closed(object sender, EventArgs e)   
{   
   Forms.Remove(object.GetType()); 
   this.WindowState = FormWindowState.Normal;   
} 

Answer 12

再次感谢yzxdc！你太有才了，哈哈
上面给的例子，应该可以解决问题。
而且可以不用复制那些代码“100遍啊，100遍”了！！再次谢谢有没有 关于设计模式里的一些高级思想，能把这个问题 高内聚一下？
还有，反射的一些机制可以帮忙解决这个问题不？请大家帮忙问问身边的高手朋友们，能否写一个10楼中最后所说的CheckForms函数呢？我就跟这个问题锚上了！顺便能跟高手们学点高级的思维。嘿嘿

Answer 13

一直没太看明白楼主的问题...按我的理解,楼可能在做一件集合管理方面的事情..有一百个成员,(但100个窗口类我觉得比较少见)因为窗口属于UI啊这么多窗口多复杂啊,一般都Node啊这些节点类对象可能非常的多才算多见.假设你要操作100个窗口来做测试也可以理解,不管怎么说吧,你可能是想让一个"变量窗口"来动态的代替要操作的具体窗口,然后实现不同的事件响应如果是这样的话我觉得是可以是,就用Form form做为变量要用的时候可以这样:form = Manager.GetInstance("id_xxx");然后在此之前统一把所有窗口的内的一个按钮的事件挂接到一个同样的方法但这个方法内部用一个switch来区别是那一个具体窗口发出的从而可以用同一个方面响应来自不同窗口的按钮事件..别的我也不知道,也不太清楚了

Answer 14

前几天也忘了贴上来了，共享下我写的东西吧。
适用于 给2个窗体绑定关系事件，利用反射，按照“潜规则”动态创建新窗体，并添加控件
public class FormFactory
{
private static Hashtable htForms=new Hashtable();
public static event System.EventHandler onChildFormClosed;
public static event System.EventHandler onChildFormLoaded; private static void Form_Load(object sender, EventArgs e)
{
Form f=(Form)sender;
f.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
AddDrinkPanel(f);
//execute selfDefined loading functions
if (onChildFormLoaded!=null)
onChildFormLoaded(sender,e);
}

private  static void Form_Closed(object sender, EventArgs e)
{
Form parentForm=(Form)((Form)sender).Tag;
if(parentForm!=null)
{
htForms.Remove(sender.GetType().Name);
parentForm.WindowState=FormWindowState.Normal;
parentForm.Activate();
}
//execute selfDefined Closing functions
if(onChildFormClosed!=null)
onChildFormClosed(sender,e);
}
private static Form GetFormByName(string nameSpace,string formName,Form parentForm,ref bool isNew)
{
if(htForms.Contains(formName))
{
Form f =(Form) Control.FromHandle((IntPtr)htForms[formName]);
if(f.Tag==null) 
f.Tag=parentForm;
isNew=false;
return f;
}
else
{
System.Runtime.Remoting.ObjectHandle oHandle;
oHandle = Activator.CreateInstance( null,nameSpace+"."+formName);
Form newForm = (Form)oHandle.Unwrap(); htForms.Add(formName,newForm.Handle);
newForm.Tag=parentForm;
isNew=true;
return newForm;
}
}
#region OpenFormByName
/// <summary>
/// Example:
/// FormFactory.OpenFormByName("ManufactureSystem","frmManufactmanageMenu",this);
/// OpenFormByName("myNameSpace.folder1.folder2","Form1",this);
/// </summary>
/// <param name="nameSpace">nameSpace and folder's name until Form</param>
/// <param name="formName">form's Name</param>
/// <param name="parentForm">current Form</param>
public static void OpenFormByName(string nameSpace,string formName,Form parentForm)
{
bool isNew=false;
Form f=GetFormByName(nameSpace,formName,parentForm,ref isNew);
if(isNew)
{
f.Load+=new EventHandler(Form_Load);
f.Closed+=new EventHandler(Form_Closed);
f.Show();
}
else
{
f.WindowState = FormWindowState.Normal;
f.Show();
f.Activate();
}
parentForm.WindowState=FormWindowState.Minimized;
}
#endregion #region ReturnFormByName
/// <summary>
/// if target Form Exists
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="formName"></param>
/// <param name="parentForm"></param>
/// <returns></returns>
public static Form ReturnFormByName(string nameSpace,string formName,Form parentForm)
{
bool isNew=false;
return GetFormByName(nameSpace,formName,parentForm,ref isNew);
}
#endregion  public static void AddDrinkPanel(Form f)
{
drinkPanel dp=new drinkPanel();
dp.Location=new System.Drawing.Point(672,0);
dp.BringToFront();
f.Controls.Add(dp);
dp.BringToFront();
dp.Font=new System.Drawing.Font("ＭＳ Ｐゴシック",9);
}

public static void btns_OnClick(object sender, EventArgs e,Form f)
{
string nameSpace=f.GetType().Namespace;
string btnName=((Button)sender).Name;
btnName=btnName.Replace("btn","frm");
//MessageBox.Show(btnName);
FormFactory.OpenFormByName(nameSpace,btnName,f);
} }