-1

我需要实现这种方法——两种数据作为一组参数发送—— Type这样一种类型就可以保存这两个参数。这样我就可以Type通过某种方法来处理它。

第一个数据项是：

  • 要显示的列，命名为： displayed

第二个数据项：

  • 该 Columns的副本（或只有一部分displayed） ，因为它具有相同的来源，所以只有这些列不会显示......换句话说，Columns 要省略，所以我将其命名为： omitted

两者都是我命名的类型 Columns -SelectedColumns

public class SelectedcColoumns
{
    public enum renederingMode
    {
        Displayed,
        omitted
    }
    public class omitted
    {

    }
    public class displayed
    {
    }
}

因为要显示的 SetOfColumns 请求是通过选择表名来完成的。因此，作为要显示的数据的 Column 类会根据用户选择的可用源 ForSelectedColumns的选择而有所不同，如下所示：

public class tableNames
{
   public static readonly string tblCustomers = "tblCustomers";
   public static readonly string tblProducts = "tblProducts";
}

public class TblColumns
{
    public class tblCustomers
    {
        public const string custID = "custID",
                            Name = "Name",
                            Phone = "Phone";
                            Email = "Email";
  
    }
    public class tblProducts 
    {
        public const string PrudctID = "PrudctID ",
                            PrudctName = "PrudctID",
                            PrudctCategory = "PrudctCategory";
    }
    ...etc'

}

当用户选择一组表列...从任何表用户可以，在这个例子中..选择一个Customers或Products列（例如SelectedColumns - 是tblCustomers列），然后我需要有另一个列表，用户选择省略的那些（不显示）来自所有可用的表列。

假设用户选择将表客户作为表。他选择省略 tblCustomers.custID+tblCustomer.Email因为他只需要显示姓名和电话。

我遇到的问题是，当这些参数在我的范围内（表名+要省略的列）时，我怎样才能将它发送到进程（将它作为One Parameter传递）？所以这就是为什么我创建了一个专用类，将其Type作为发送参数：all columns+omitted Columns放在一起。

这是我目前卡住的地方；我需要知道如何使用它来构建/构造用户选择的参数。

public class SelectedColoumns
{
    public enum renederingMode
    {
        Displayed,
        omitted
    }
        public class omitted
        {
           List<string> omitCols_ListStr = new List<string>();
        }
       
        public class displayed
        {
           List<string> dispCols_ListStr = new List<string>();
        }
}

在这一部分中，我通过以下方法检索reflection作为数据提供者的列列表：

获取任何嵌套类字段， As List<string>，通过嵌套class-name和它的父级- Type。

public static List<string> anyNestedClassFiledsAsListByType<ClassToReturnOneOfitsNested_Fields>(string NetedClassName)
 {
                var RetNestedClassFildsListValues = typeof(ClassToReturnOneOFitsNested).GetNestedTypes()
                    .First(t => String.Compare(t.Name, NetedClassName, true) == 0).GetFields(BindingFlags.Public | BindingFlags.Static)
                    .Where(f => f.FieldType == typeof(string)).Select(f => (string)f.GetValue(null)).ToList();
                return RetNestedClassFildsListValues;
            }

所以要产生这个我可以使用上面的方法就像那样

var TableColumns_ALL = 
anyNestedClassFldsAsListByType<TblColumns>(tableNames.tblCustomers);

我的问题与需要发送 TableColumns_ALL + 选择的列以省略然后由renderSelectedTable()下面处理的类有关。

所以它比反射的复杂性更基本，但仍然有些我不知道构造的popper方法SelectedColumns class，所以它将容纳和格式化这种新数据类型的结构，该结构将作为方法的参数发送像这样的东西。

public void renderSelectedTable(SelectedColoumns CurrentUserSelectedCols)
{
    StringBuilder NwTRLoopSB = new StringBuilder();

    string curRowStyle= string.Empty,
           nwLine = Environment.NewLine + "\t\t\t",
           BaseTemplateTD = string.Empty;

    NwTRLoopSB.Append(
            string.Format(
                "<table id='tbl_Settings' cellspacing='0' border='1'><tr id='TR_headers'{0}>{1}",
                curRowStyle,
                nwLine
                )._Dhtml_DoubleQoutes()
        );
    foreach (var Item in SelectedListStr.Select((Val, counter) => new { Value = Val, Index = counter }))
    {
            curRowStyle = Lsts.DynamicStyle_Generator(Item.Index);

            if(Lsts.ExcludeColumns(Item.Value, OmittedCols))
            {
                BaseTemplateTD = string.Format("<td>{0}</td>{1}", Item.Value, nwLine)._Dhtml_DoubleQoutes();
                NwTRLoopSB.Append(BaseTemplateTD);
            }    
      
    }///ENd TR cells generator Section

    NwTRLoopSB.Append("</tr></table>");
    return NwTRLoopSB.ToString();

}
4

2 回答 2

1

我会这样处理：

public class Column{
    public string Name { get; set; }
    public bool Visible { get; set; }
}

public class Grid{
    public List<Column> Columns { get; set; }
}

所以我可以很容易地用可见或省略的列定义我的完整表。在 OP 的示例中：

public class SelectedColumns
{
    //instead of the enum you would have boolean in the column type "Visible" (whether is shown or not)
    public enum renederingMode
    {
        Displayed,
        omitted
    }
    // instead of both these you would have a List o Column types that have a name AND a boolean, so you have your List<string> and a boolean to indicate whether it is visible or ommited. Well at least that's how I understood it.
    public class ommited
    {

    }
    public class displayed
    {
    }
}
于 2012-12-19T20:24:32.723 回答
0

所以..首先..一个设计说明：给定一个列列表..您将显示一列，或者不显示一列..在可见性方面没有其他选项。因此，您实际上只需要传入要显示的列或要省略的列的单个列表 - 但不能同时传递两者。

如果您选择进行该修改，那么您只需传入一个List<string>

如果您选择保留当前的设计，那么您将需要一个包含两个的类properties：

public class SelectedColumns {
    public List<string> displayed { get; set; }
    public List<string> omitted { get; set; }
}
于 2012-12-19T20:12:31.270 回答