如何在C＃中最小化表单和类之间的依赖关系 [英] how to minimize dependency between a form and a class in C#

问题描述

在这个示例代码（C＃winForms app）中，有一个带有`SearchEmployee（）`方法的`Employee`类和一个带有`GetByEmployeeID（）`方法的`DataService`类。在搜索员工时，`SearchEmployee（`）方法将调用`GetByEmployeeID（）`方法与数据库通信。我通过使用构造函数注入最小化了`Employee`类和`DataService`类之间的依赖关系。 （以最简单的方式使用接口）



但是`Form`类和`Employee`类之间存在依赖关系，因为我是`new`员工对象来自`from`class。



这种依赖性是一个问题还是不是？



如果那样应该避免依赖，实现这个目标最简单的方法是什么？

如果你能回答代码，请感谢。



我不喜欢使用类似MVP的模式，因为我不熟悉它。

In this sample code (C# winForms app) there is a `Employee` class with `SearchEmployee()` method and a `DataService` class with `GetByEmployeeID()` method. When searching for a employee, `SearchEmployee(`) method will call `GetByEmployeeID()` method to talk to database. I have minimized the dependency between `Employee` class and `DataService` class by using constructor injection. (in its simplest way with out using an Interface)

But there is a dependency between `Form` class and `Employee` class as I `new` employee object from `From` class.

Will that dependency be a problem or isn't?

If that dependency should be avoided, What is the simplest way to achieve this?
Appreciate if you could answer with code.

I prefer not to use a pattern like MVP as I'm not familiar with it.

Class Form
    {
        public Form()
        {
            InitializeComponents();
        }
    
            private void btnSave_Click(object sender, EventArgs e)
            {
                    Employee newEmp = new Employee (new DataService()); //Making a dependency 
                    newEmp = newEmp.SearchEmployee (txtEmployeeID.Text);
                    txtEmployeeName.Text = newEmp.EmployeeName;
                    txtEmployeeAddress.Text = newEmp.EmployeeAddress;
            }
    }
    
    
    Class Employee
    {
            string EmployeeID  { get; set; }
            string EmployeeName { get; set; }
            string EmployeeAddress { get; set; }
    
            DataService _DS;
    
            public Employee(DataService DS) //Constructor injection of dataservice object
            {
                this._DS = DS;
            }
    
            public Employee SearchEmployee (string employeeID)
            {
                this.EmployeeID  =employeeID;
    
                DataTable DT= _DS.GetByEmployeeID(EmployeeID);
                this.EmployeeName = DT.Rows[0].ItemArray[1].ToString();
                this.EmployeeAddress = DT.Rows[0].ItemArray[2].ToString();
    
                return this; //Returning an employee object to the caller
            }
    }
    
    
    //This class responsible for database transaction
    
     class DataService
        {
    
            public DataTable GetByEmployeeID(string employeeID)
            {
                using (SqlConnection newCon = new SqlConnection(db.GetConnectionString))
                {
                    SqlCommand Cmd = new SqlCommand("SELECT..WHERE emp_id=@employeeID", newCon);
                    Cmd.Parameters.Add("@employeeID", SqlDbType.varChar).Value = employeeID;
                    newCon.Open();
                    SqlDataReader rdr = Cmd.ExecuteReader();
                    DataTable results = new DataTable();
                    results.Load(rdr);
    
                    return results;
                }
            }
        }

推荐答案

为了利用松散耦合，我建议你改变你的设计并像这样使用MVC;

To take advantage of loose coupling, I suggest you to change your design and use MVC like this;

[STAThread]
static void Main()
{
	Application.EnableVisualStyles();
	Application.SetCompatibleTextRenderingDefault(false);

	var view = new FormMain();
	var controller = new Controller(view, new EmployeeManager(new DataService()));

	Application.Run(view);
}


public partial class FormMain : Form
{
	private Controller _controller;

	public FormMain()
	{
		InitializeComponent();
	}

	public void SetController(Controller controller)
	{
		_controller = controller;
	}

	private void button1_Click(object sender, EventArgs e)
	{
		var newEmp = _controller.SearchEmployee(txtEmployeeID.Text);
                if(null == newEmp) 
                {
                   //Id is not found.
                }
		txtEmployeeName.Text = newEmp.EmployeeName;
		txtEmployeeAddress.Text = newEmp.EmployeeAddress;
	}
}

public class Controller
{
	private FormMain _view;
	private EmployeeManager _manager;


	public Controller(FormMain view, EmployeeManager manager)
	{
		_view = view;
		_manager = manager;
		view.SetController(this);
	}

	public Employee SearchEmployee(string employeeID)
	{
	   return _manager.SearchEmployee(employeeID);
	}

	private void UpdateService(DataService newService)
	{
		_manager = new EmployeeManager(newService);
	}

}

public class EmployeeManager
{

	private DataService _ds;

	public EmployeeManager(DataService DS)
	{
		_ds = DS;
	}

	public Employee SearchEmployee(string employeeID)
	{

		var dt = _ds.GetByEmployeeId(employeeID);

		if (dt.Rows.Count > 0)
		{

			return new Employee(employeeID,
								dt.Rows[0].ItemArray[1].ToString(),
								dt.Rows[0].ItemArray[2].ToString());
		}
		return null;
	}

	//ADD DELETE UPDATE METHODS etc.

}

public class Employee
{
	public string EmployeeID { get; set; }
	public string EmployeeName { get; set; }
	public string EmployeeAddress { get; set; }


	public Employee(string employeeID, string employeeName, string employeeAddress)
	{
		EmployeeID = employeeID;
		EmployeeName = employeeName;
		EmployeeAddress = employeeAddress;
	}
}

public class DataService
{
	public DataTable GetByEmployeeId(string employeeID)
	{
		using (SqlConnection newCon = new SqlConnection(""))
		{
			SqlCommand Cmd = new SqlCommand("SELECT..WHERE emp_id=@employeeID", newCon);
			Cmd.Parameters.Add("@employeeID", SqlDbType.VarChar).Value = employeeID;
			newCon.Open();
			SqlDataReader rdr = Cmd.ExecuteReader();
			DataTable results = new DataTable();
			results.Load(rdr);
			return results;
		}
	}
}

好点。我建议你去看看 MEF [ ^ ]。顺便提一下，这些天我见过的最好的问题之一。

good point. I advice you to take a look to MEF[^]. one of the best questions I have seen in these days, by the way.

这篇关于如何在C＃中最小化表单和类之间的依赖关系的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！