Question

我创建了一个静态类，其中包含在控制器操作中使用的方法，其目的不是将逻辑放在控制器操作中，因此这个类的示例是：

namespace MyTestProject.Infrastructure.Handler
{
public static class ControllerHandler
{
    public static string GetUserName(GetLoggedUserResponse user)
    {
        string username = string.Empty;

        if (user != null)
        {
            username = user.Nombre;
        }

        return username;
    }
    private static List<Menu> GetVisibleChildMenus(GetLoggedUserResponse user, int idMenu, bool tab)
    {
        return user.MenusPerfiles.Where(mp => mp.Menu.IdPadre == idMenu
                                              && mp.Menu.Visible.Value
                                              && mp.Menu.Tab.Value == tab)
                                                     .Select(mp => mp.Menu)
                                                     .OrderBy(m => m.Orden)
                                                     .ToList();
    }

    public static List<Navbar> GetNavBar(GetLoggedUserResponse user, PathString requestPath)
    {
        List<Navbar> navbar = new List<Navbar>();

        if (user != null)
        {
            //menu correspondiente a la pantalla actual
            Menu menu = user.MenusPerfiles.Where(mp => mp.Menu.Ruta.StartsWith("/") && requestPath.StartsWithSegments(mp.Menu.Ruta))
                                          .Select(mp => mp.Menu)
                                          .FirstOrDefault();

            if (menu != null)
            {
                //hijos en modo tab
                List<Menu> menus = GetVisibleChildMenus(user, menu.Id.Value, true);

                menus.ForEach(m =>
                {
                    //hijos del menu tab (se mostraran en forma de lista desplegable)
                    List<Menu> menusTab = GetVisibleChildMenus(user, m.Id.Value, false);
                    var navbarMenus = new List<NavbarMenu>();

                    menusTab.ForEach(mt =>
                    {
                        navbarMenus.Add(new NavbarMenu
                        {
                            link = mt.Ruta,
                            title = mt.Nombre
                        });
                    });

                    navbar.Add(new Navbar
                    {
                        title = m.Nombre,
                        icon_css = m.CssIcon,
                        class_css = menusTab == null || menusTab.Count() > 0 ? "" : "dropdown",
                        link = m.Ruta,                           
                        menus = navbarMenus
                    });
                });
            }
        }

        return navbar;
    }

    public static Sidebar GetSideBar(GetLoggedUserResponse user)
    {
        Sidebar sidebar = null;

        if (user != null)
        {
            sidebar = new Sidebar();

            List<Menu> menus = user.MenusPerfiles.Where(mp => mp.Menu.Visible.Value && !mp.Menu.IdPadre.HasValue).Select(mp => mp.Menu).OrderBy(m => m.Orden).ToList();

            menus.ForEach(m =>
            {
                var sidebarMenus = new Menus();

                //hijos en modo tab
                List<Menu> childMenus = GetVisibleChildMenus(user, m.Id.Value, false);

                childMenus.ForEach(cm =>
                {
                    sidebarMenus.Add(new SidebarMenu {title = cm.Nombre, url = cm.Ruta, position = cm.Orden.Value });
                });

                sidebar.Add(new SidebarButton
                {
                    title = m.Nombre,
                    icon_css = m.CssIcon,
                    position = m.Orden.Value,
                    id = m.Id.Value,
                    visible = true,
                    menus = sidebarMenus
                });
            });                
        }
        else
        {
            sidebar = new Sidebar {
               new SidebarButton {
                   title = "Dashboard", icon_css = "s7-monitor", position = 1, id = 1, visible = true,
                   menus = new Menus(){
                        new SidebarMenu { title = "Main Dashboard", url = "/", position = 1 }}}               
            };
        }

        return sidebar;
    }

    public static ReportViewModel GetReport(string reportId, string accessToken)
    {
        GetReportResponse report = ApiHandler.GetReport(reportId, accessToken);

        var reportsViewModel = new ReportViewModel() { Reports = new List<Report>() };

        report.Reports.ForEach(r =>
        {
            reportsViewModel.Reports.Add(new Report { Id = r.ReportId,
                                                      EmbedUrl = r.EmbedUrl,
                                                      AccessToken = r.AccessToken,
                                                      VisibleScreenSize = r.VisibleScreenSize,
                                                      HiddenScreenSize = r.HiddenScreenSize });
        });

        return reportsViewModel;
    }

    public static async Task<GetNotificationResponse> GetNotifications(string all, string accessToken)
    {
        GetNotificationResponse result = await ApiHandler.GetNotifications(all, accessToken);

        return result;
    }

...

但在我看来，这似乎是一个坏主意，因为这个课程有多个责任，这是正确的吗？那么拆分这个课更好吗？在那种情况下，我不喜欢的是在控制器操作中我们必须处理实例很多类，我喜欢我们有一个“单点”或类似的东西，这有助于控制器访问所有这些方法你觉得怎么样？这有什么设计模式吗？。

此类方法（获取用户名，构建菜单，获取用户通知）是放在基础结构命名空间下的方法吗？

Answer 1

您正在使用此静态类，更像是库，以获取对控制器有用的常用方法。开发人员创建常用方法的静态库肯定并不罕见，并且库通常包含可能没有什么共同之处的方法。

但是在这种情况下，由于所有方法都是由Controller使用的，您可以创建一个类，可能称为Base Controller，它继承自Controller并实现这些方法（而非静态）。然后，您可以让网站中的控制器继承自BaseController。这将使您的控制器可以使用这些便捷方法，而无需引用静态类。这种方法也被广泛使用，对于您的特定情况可能是更好的选择。

一个静态控制器处理程序来管理控制器中使用的方法......¿

1 个答案: