C# 和 Visual Studio 2005 中的程序集之间的循环引用

Question

我正在努力标准化所有应用程序的分层/多层设计的单一方式。

我正在尝试将我的所有应用程序设为 5 层。

代码：

---

| 用户界面|

|

| 业务对象|

|

| 或映射器 |

|

| 数据访问|

|

| 关系型数据库管理系统

假设我正在开发一个具有用户登录/注销功能的应用程序。 我正在 VS2005 解决方案下创建 4 个项目。 每个项目都是针对上面 4 层之一。 我正在设计我的业务对象类，如下所示： -

public class User
{
    private string _username;
    public string Username
    {
        get { return _username; }
        set { _username = value; }
    }

    private string _password;
    public string Password
    {
        get { return _password; }
        set { _password = value; }
    }

    public User()
    {
    }

    public bool LogIn(String username, String password)
    {
        bool success = false;

        if (UserMapper.UsernameExists(username))
        {
            success = UserMapper.UsernamePasswordExists(username, password);
        }
        else
        {
            //do nothing
        }

        return success;
    }

    public bool LogOut()
    {
           bool success;
        //----some logic
           return success;
    }

    public static User GetUserByUsername(string username)
    {
        return UserMapper.GetUserByUsername(username);
    }

    public static UserCollection GetByUserTypeCode(string code)
    {
        return UserMapper.GetByUserTypeCode(code);
    }
}

这就是我为我的对象提供一些与现实世界场景相匹配的功能的方式。 这里 GetByUsername() 和 GetByUserTypeCode() 是 getter 函数。 这些函数与现实世界的逻辑不匹配。 因为在现实世界中，用户永远不会“通过用户名获取”或“通过用户类型代码获取”。 所以这些函数保持静态。

我的 OR Mapper 层的类如下：-

public static class UserMapper
{
    public static bool UsernameExists(String username)
    {
        bool exists = false;

        if (UserDA.CountUsername(username) == 1)
        {
            exists = true;
        }

        return exists;
    }

    public static bool UsernamePasswordExists(String username, String password)
    {
        bool exists = false;

        if (UserDA.CountUsernameAndPassword(username, password) == 1)
        {
            exists = true;
        }

        return exists;
    }
}

最后，DA 类如下：-

public static class UserDA
{
    public static int CountUsername(string username)
    {
        int count = -1;

        SqlConnection conn = DBConn.Connection;

        if (conn != null)
        {
            try
            {
                SqlCommand command = new SqlCommand();
                command.Connection = conn;
                command.CommandText = @"SELECT COUNT(*) 
                                FROM User 
                                WHERE User_name = @User_name";
                command.Parameters.AddWithValue("@User_name", username);

                command.Connection.Open();
                object idRaw = command.ExecuteScalar();
                command.Connection.Close();

                if (idRaw == DBNull.Value)
                {
                    count = 0;
                }
                else
                {
                    count = (int)idRaw;
                }
            }
            catch (Exception ex)
            {
                count = -1;
            }
        }

        return count;
    }  

    public static int CountUsernameAndPassword(string username, string password)
    {
        int count = 0;

        SqlConnection conn = DBConn.Connection;

        if (conn != null)
        {
            try
            {
                SqlCommand command = new SqlCommand();
                command.Connection = conn;
                command.CommandText = @"SELECT COUNT(*) 
                                FROM User 
                                WHERE User_name = @User_name AND Pass_word = @Pass_word";
                command.Parameters.AddWithValue("@User_name", username);
                command.Parameters.AddWithValue("@Pass_word", password);

                command.Connection.Open();
                object idRaw = command.ExecuteScalar();
                command.Connection.Close();

                if (idRaw == DBNull.Value)
                {
                    count = 0;
                }
                else
                {
                    count = (int)idRaw;
                }
            }
            catch (Exception ex)
            {
                count = 0;
            }
        }

        return count;
    }

    public static int InsertUser(params object[] objects)
    {
        int count = -1;

        SqlConnection conn = DBConn.Connection;

        if (conn != null)
        {
            try
            {
                SqlCommand command = new SqlCommand();
                command.Connection = conn;
                command.CommandText = @"INSERT INTO User(ID, User_name, Pass_word, RegDate, UserTypeCode, ActualCodeOrRoll) 
                                                            VALUES(@ID, @User_name, @Pass_word, @RegDate, @UserTypeCode, @ActualCodeOrRoll)";
                command.Parameters.AddWithValue("@ID", objects[0]);
                command.Parameters.AddWithValue("@User_name", objects[1]);
                command.Parameters.AddWithValue("@Pass_word", objects[2]);
                command.Parameters.AddWithValue("@RegDate", objects[3]);
                command.Parameters.AddWithValue("@UserTypeCode", objects[4]);
                command.Parameters.AddWithValue("@ActualCodeOrRoll", objects[5]);

                command.Connection.Open();
                count = command.ExecuteNonQuery();
                command.Connection.Close();
            }
            catch (Exception ex)
            {
                count = -1;
            }
        }

        return count;
    }

    public static SqlDataReader GetUserByUsername(string username)
    {
        SqlDataReader dataReader = null;

        SqlConnection conn = DBConn.Connection;

        if (conn != null)
        {
            try
            {
                SqlCommand command = new SqlCommand();
                command.Connection = conn;
                command.CommandText = @"SELECT * FROM User WHERE User_name = @User_name";
                command.Parameters.AddWithValue("@User_name", username);

                command.Connection.Open();

                dataReader = command.ExecuteReader(CommandBehavior.CloseConnection);

            }
            catch (Exception ex)
            {
                dataReader.Close();
                dataReader.Dispose();
            }
        }

        return dataReader;
    }

    public static SqlDataReader GetUserByUserTypeCode(string userTypeCode)
    {
        SqlDataReader dataReader = null;

        SqlConnection conn = DBConn.Connection;

        if (conn != null)
        {
            try
            {
                SqlCommand command = new SqlCommand();
                command.Connection = conn;
                command.CommandText = @"SELECT * FROM User WHERE UserTypeCode = @UserTypeCode";
                command.Parameters.AddWithValue("@UserTypeCode", userTypeCode);

                command.Connection.Open();

                dataReader = command.ExecuteReader(CommandBehavior.CloseConnection);

            }
            catch (Exception ex)
            {
                dataReader.Close();
                dataReader.Dispose();
            }
        }

        return dataReader;
    }
}

如果有人仔细检查这些类，他就会明白，OR Mapper 层需要 BusinessObject 层的引用。 BusinessObject层还需要OR Mapper层的引用。

这应该会创建一个循环依赖。

我怎样才能避免这个问题？

有人建议使用普通数据传输对象（DTO）。 但是，据我所知，根据 OOP，现实世界对象的属性和功能应该组合在一起作为一个类。 如果我使用 DTO 那么如何将功能封装到类中？ 此外，我正在创建另一个没有任何属性（BO）的类。 对我来说，这在两个方面都违反了面向对象编程。 如果我这样做了，那么 OOP 在这个世界上还有什么用呢？ 相同的答案可以应用于“UserManager”类。

我找到了一个博客。

它讨论了接口的实现。 定义一个单独的接口，在 BusinessObject 的数据类中实现它，并根据 BusinessObject 和 OR-Mapper 层中的接口进行编程。

但我做不到。

谁能用一个实际的例子告诉我这一点？

Answer 1

我认为您可以做一些事情，这些事情一起可以帮助您的设计。 我还认为您可能想阅读依赖注入，因为也许提供了更好的设计模式为了你想做的事。

假设您只想使您所拥有的功能正常工作：

• 首先，从您的 User 类中删除 static 方法，因为它们“创建”用户，因此最好留在 UserMapper 上。

• 之后，仍然有许多方法可能使用 User 类中的 UserMapper 功能。 创建一个支持 UserNameExists 和 UserNamePasswordExists 方法的接口 IUserLookup （或其他东西）； 将此接口与 User 类放在同一个项目中。

• 在 UserMapper 类上实现 IUserLookup，然后将其“注入”到它使用静态方法创建的 User 类实例中一个构造函数，所以基本上，当 UserMapper 创建 User 对象时，它会为它们提供对其自身实现的 IUserLookup 接口的引用。

这样，User仅使用IUserLookup上的方法，该方法位于同一解决方案中，因此不需要引用。 而UserMapper引用了这个解决方案，因此它可以创建User对象并实现IUserLookup接口。

Answer 2

如果 OR 映射器实际上在执行 OR，那么它可能不需要对 BL 的引用 - 它只需要知道类型（是） ） 涉及。 但这是一个附带问题...

此类问题的主要答案是“控制反转”/“依赖注入”，大概会剪切 BL 下的所有内容 - 因此 BL 只依赖于一个接口（在基础程序集中定义） ），但不知道具体的 OR/DA/RDBMS（它们由 IoC/DI 提供）。

这是一个很大的话题，所以我故意含糊其辞。 我个人喜欢 StructureMap，但是有很多 IoC/DI 工具可用。

请注意，从技术上讲，创建循环装配引用是可能的； 不过，这是一个非常坏主意 - 而且这些工具会（故意）在每一步与您作斗争。

Answer 3

在您上面提交的代码中，没有循环依赖的证据。

当您的调用从上层传输到底层时...您的对象转换为适合每一层的专业化（但是在您的情况下，您正在处理每一层上的基元...至少在提交的代码中）...并且当您的调用返回时，它应该从专业化转向泛化......

这可能反之亦然，并且如果以这种方式观察到单个路径，则不存在循环依赖问题。 然而，如果在任何分层中，您尝试为两侧信息传输路径实现规范化场景，那么我们就会遇到问题，因为每个层都将依赖并需要其封闭层的引用。

但在您的代码中没有这种循环依赖的证据。 但是，如果存在这种情况，可以通过实现接口层或适配器模式（接口层是适配器模式）来避免这种情况。

例如，我们有一个 Layer InformationTravel (IT)...（好吧，我明白这听起来不太好）

| 用户界面|
|
| 资讯旅游 | **
|
| 业务对象|
|
| 或映射器 |
|
| 数据访问|
|
| 关系型数据库管理系统

您所做的就是为您的用户业务对象声明一个接口 IUser 并在用户业务对象中实现它......

然后 BO 就有了 IT 的引用。 对象创建应该只在 BO 层实现 IT 接口。这是完全可以的。 当您需要将此对象传递给 ORM 时，您可以通过将其切片到 IT 中实现的接口来传递它，当您收到它时，您在进行必要的修改后再次返回相同的对象。

但这再次暗示您无法在多个层创建 BO，因为只有 BO 具有接口的实现。 但是，如果您确实无法避免这种情况，那么您必须在多个位置提供实现或使用适配器模式（将您的对象封装到客户端期望的另一个对象中）。

Answer 4

为了防止程序集之间的循环引用，您应该使用接口。例如，如果您的 OR-Mapper 需要调用 BL 的某些成员，您应该识别这些成员并将它们放入一个或多个接口中，然后将它们放入程序集中（例如接口）或者在您的 OR-Mapper 程序集中，让您的 BL 对象实现它们，然后就不需要在您的 OR-Mapper 程序集中引用您的 BL。