C# Linq框架如其他答案所示

然而，如果你想要一种更为“零原则”的方法，为你的专栏中的每一项提供计数，我建议如下。请注意，此方法实际上更加灵活，因为它返回该列中每个项的计数的字典或“映射”，而不仅仅是您要查找的项。然后，您需要做的就是查询特定项目的地图

private DataTable dt;

...

private Dictionary<string, int> countColumnOccurances(int columnIndex)
{
    //Make a unique list of Items for the column of interest
    string indexName = dt.Columns[columnIndex].ColumnName;
    DataView view = new DataView(dt);
    DataTable distinctColumnDT = view.ToTable(true, dt.Columns[columnIndex].ColumnName);
    List<String> listOfDistinctItems = new List<String>();
    foreach (DataRow r in distinctColumnDT.Rows)
    {
        listOfDistinctItems.Add(r[indexName].ToString());
    }
    //Associate each of these items with a count
    var itemsAndTheirCount = new Dictionary<String, int>();
    int count = 0;
    foreach (var l in listOfDistinctItems)
    {
        foreach (DataRow r in dt.Rows)
        {
            if (l == r[indexName].ToString())
            {
                count++;
            }
        }
        itemsAndTheirCount.Add(l, count);
        count = 0;
    }
    return itemsAndTheirCount;
}

私有数据表dt；
...
专用字典countColumnOccurances（int columnIndex）
{
//为感兴趣的列创建唯一的项目列表
string indexName=dt.Columns[columnIndex].ColumnName；
数据视图=新数据视图（dt）；
DataTable distinctColumnDT=view.ToTable（true，dt.Columns[columnIndex].ColumnName）；
List listOfDistinctItems=新列表（）；
foreach（distinctColumnDT.Rows中的数据行r）
{
添加（r[indexName].ToString（））；
}
//将这些项目中的每个项目与计数关联
var itemsAndTheirCount=新字典（）；
整数计数=0；
foreach（列表中的变量l）
{
foreach（数据行r在dt.行中）
{
如果（l==r[indexName].ToString（））
{
计数++；
}
}
项目及其计数相加（l，计数）；
计数=0；
}
返回项目及其计数；
}

---

包含详细性和详细性，因此您可以遵循逻辑，但是，您可以轻松减少行数。

最佳实践方法当然是采用Linq框架，如其他答案所示

然而，如果你想要一种更为“零原则”的方法，为你的专栏中的每一项提供计数，我建议如下。请注意，此方法实际上更加灵活，因为它返回该列中每个项的计数的字典或“映射”，而不仅仅是您要查找的项。然后，您需要做的就是查询特定项目的地图

private DataTable dt;

...

private Dictionary<string, int> countColumnOccurances(int columnIndex)
{
    //Make a unique list of Items for the column of interest
    string indexName = dt.Columns[columnIndex].ColumnName;
    DataView view = new DataView(dt);
    DataTable distinctColumnDT = view.ToTable(true, dt.Columns[columnIndex].ColumnName);
    List<String> listOfDistinctItems = new List<String>();
    foreach (DataRow r in distinctColumnDT.Rows)
    {
        listOfDistinctItems.Add(r[indexName].ToString());
    }
    //Associate each of these items with a count
    var itemsAndTheirCount = new Dictionary<String, int>();
    int count = 0;
    foreach (var l in listOfDistinctItems)
    {
        foreach (DataRow r in dt.Rows)
        {
            if (l == r[indexName].ToString())
            {
                count++;
            }
        }
        itemsAndTheirCount.Add(l, count);
        count = 0;
    }
    return itemsAndTheirCount;
}

私有数据表dt；
...
专用字典countColumnOccurances（int columnIndex）
{
//为感兴趣的列创建唯一的项目列表
string indexName=dt.Columns[columnIndex].ColumnName；
数据视图=新数据视图（dt）；
DataTable distinctColumnDT=view.ToTable（true，dt.Columns[columnIndex].ColumnName）；
List listOfDistinctItems=新列表（）；
foreach（distinctColumnDT.Rows中的数据行r）
{
添加（r[indexName].ToString（））；
}
//将这些项目中的每个项目与计数关联
var itemsAndTheirCount=新字典（）；
整数计数=0；
foreach（列表中的变量l）
{
foreach（数据行r在dt.行中）
{
如果（l==r[indexName].ToString（））
{
计数++；
}
}
项目及其计数相加（l，计数）；
计数=0；
}
返回项目及其计数；
}

---

包含详细信息和详细信息，因此您可以遵循逻辑，但是，您可以轻松减少行数。

是的，但如果我没有弄错，他会从某个DB获取数据，如果我从DB id获取数据，而不是在DB上进行计数/分组/排序，则使用c#是，但如果我没有弄错，他会从某个DB获取数据，如果我从DB id获取数据，而不是在DB上进行计数/分组/排序，那么在匿名类型列表的c#up one中，这是非常棒的，我已经使用它很多年了，但是我现在遇到了问题，因为源包含混合数据—一些较高的数据和一些较低的数据。此代码不会忽略大小写。这是一个很好的例子，我已经用了很长时间了，但是我现在遇到了麻烦，因为源文件包含混合数据，有些是大写的，有些是小写的。此代码不会忽略大小写。如何制作或是否可以全部大写。引用有2'r；）事件有2个'r；）

var tblAccCounts = new DataTable();
tblAccCounts.Columns.Add("Account#");
tblAccCounts.Columns.Add("Count", typeof(int));

foreach(var grp in accountGroups)
    tblAccCounts.Rows.Add(grp.Account, grp.Count);

SELECT Account#, Count(*) FROM [Table] GROUP BY Account#

var results = DataTable.Rows
    .Cast<DataRow>()
    .GroupBy(row => row.Field<string>(0))
    .Select(g => new { Account = g.Key, Occurrences = g.Count()});

DataTable newTable = new DataTable();
newTable.Columns.Add(new DataColumn("Account#", typeof(string)));
newTable.Columns.Add(new DataColumn("Occurrences", typeof(int)));

foreach(var result in results)
{
    var row = newTable.Rows.NewRow();
    row[0] = result.Account;
    row[1] = result.Occurrences;
    newTable.Rows.Add(row);
}

class Program
    {
        static void Main(string[] args)
        {
            testClass tc = new testClass();
            DataTable dt = tc.getTestData();

            for(int i = 0; i < dt.Rows.Count; i++)
            {
                Console.WriteLine("Account No {0} Occurence {1}", dt.Rows[i]["ACCNO"].ToString(), dt.Rows[i]["Occurence"].ToString());
            }
        }
    }

    class testClass
    {
        public string AccountNo { get; set; }

        private SqlConnection Conn;

        private void TestConnect()
        {
            string strConn = "Data source = .\\SQLEXPRESS2012; Initial catalog = TEST; Integrated security = SSPI;";
            Conn = new SqlConnection(strConn);
        }

        public DataTable getTestData()
        {
            TestConnect();
            string cmdStr = "SELECT ACCNO, COUNT(XYZ.ACCNO) AS 'Occurence' FROM XYZ GROUP BY ACCNO;";
            SqlCommand cmd = new SqlCommand(cmdStr, Conn);
            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            DataTable dt = new DataTable();
            try
            {
                Conn.Open();
                sda.Fill(dt);
            }
            catch (SqlException se)
            {
                Console.WriteLine("Error occured {0}", se.ToString());
            }
            finally
            {
                Conn.Close();
            }

            return dt;
        }
    }

// Create Results DataTable

DataTable ResultsDataTable = new DataTable();
ResultsDataTable.Columns.Add("Account#"); // Columns default to System.string
ResultsDataTable.Columns.Add("Occurances", Type.GetType("System.Int32"));

ResultsDataTable.AcceptChanges(); //This asserts any changes to your table structure.

// Populate Results DataTable

foreach (DataRow SourceDataRow in SourceDataTable.Rows)
{
    string AccountNumber = SourceDataRow["Account#"].ToString();

    bool IsPresent = false;

    foreach(DataRow ResultsDataRow in ResultsDataTable.Rows)
    {
        if(ResultsDataRow["Account#"].ToString() == AccountNumber)
        {
            ResultsDataRow["Occurances"] = ((int)ResultsDataRow["Occurances"]) + 1; //Row exists for this account number, so increment the occurances value

            IsPresent = true;

            break;

        }

    }

    if (!IsPresent)
    { 
        // There isn't a row for this Account number, so create one and set it to one.

        DataRow NewResultsRow = ResultsDataTable.NewRow();

        NewResultsRow["Account#"] = AccountNumber;

        NewResultsRow["Occurances"] = 1;

        ResultsDataTable.Rows.Add(NewResultsRow);

        ResultsDataTable.AcceptChanges();

    }

}

ResultsDataTable.AcceptChanges();

private DataTable dt;

...

private Dictionary<string, int> countColumnOccurances(int columnIndex)
{
    //Make a unique list of Items for the column of interest
    string indexName = dt.Columns[columnIndex].ColumnName;
    DataView view = new DataView(dt);
    DataTable distinctColumnDT = view.ToTable(true, dt.Columns[columnIndex].ColumnName);
    List<String> listOfDistinctItems = new List<String>();
    foreach (DataRow r in distinctColumnDT.Rows)
    {
        listOfDistinctItems.Add(r[indexName].ToString());
    }
    //Associate each of these items with a count
    var itemsAndTheirCount = new Dictionary<String, int>();
    int count = 0;
    foreach (var l in listOfDistinctItems)
    {
        foreach (DataRow r in dt.Rows)
        {
            if (l == r[indexName].ToString())
            {
                count++;
            }
        }
        itemsAndTheirCount.Add(l, count);
        count = 0;
    }
    return itemsAndTheirCount;
}