我如何使用字典来满足我的要求?

本文关键字：我的满足何使用字典 | 更新日期: 2023-09-27 18:07:58

嗨，我有一个要求，如选择多个值，然后删除。我将有一些EMployee IDs以及Dates和PayID值的列表。

我将得到多个字段。现在我想将其添加到字典元素中，例如对于特定的EmpID，我必须将Date and PayID分配为键。

我想这样写

public struct MyValue
{
    public List<int> lst;
    public List<int> lst1;
    public List<DateTime> lstdt;
}
public class MyDictionary : Dictionary<int, MyValue>
{
    public void Add(int key, List<int> lst1, List<int> lst2, List<DateTime> lstDt1)
    {
        MyValue v1=new MyValue();
        v1.lst = lst1;
        v1.lst1 = lst2;
        v1.lstdt = lstDt1;
        this.Add(key, v1);
    }
}

但是我在处理这个问题时有点困惑，所以有人能给我一个想法来实现我的要求吗?

这是我的要求，如果我将EmpID设置为1，那么我将Multiple PayIDs and Dates设置为1 and System Date。

即使我将得到多个EmpIDs，但如果已经存在于字典中作为Key元素，我不想再添加它。

(使用2.0框架)

我该怎么做?

这就是我在做什么，我将有一个网格与复选框删除记录。gridview包含EmpID、PayID和Date

现在，如果用户选择了一些多个复选框并试图删除，我想将值存储到Dictionary。我将从选择中获得多个EmpID，其中相同的EmpID可能存在多次。所以我需要做的是，我想将相应的值存储到Dictionary, EmpID作为Key值，Values作为字典的倍数，这将是PayID and Date。

我的Gridview结构示例

       Chkbox     EmpID    PayID     Date
        chk        123       1     8-31-2011
        chk        123       2     10-31-2011
        chk        1234       1     18-31-2011
        chk        1234       1     19-31-2011

EmpID 123我想分配1,2 and the 2 dates作为值

我如何使用字典来满足我的要求?

为什么不创建一个包含所有员工信息的employee类型呢?

public class Employee
{
   List1<>()
   List2<>()
   List3<>()
}

然后有一个像这样的字典:

Dictionary<int, Employee>();

你可以在字典中使用字典

,

Dictionary<int, Dictionary<int, DateTime>> dict = new Dictionary<int, Dictionary<int, DateTime>>();

与

相关

Dictionary<EmpID, Dictionary<PayID, Date>>

因此，要获取员工的特定工资ID的日期，将为

    Dictionary<int, Dictionary<int, DateTime>> dict = new Dictionary<int, Dictionary<int, DateTime>>();
    int EmpID = 1;
    int PayRateID = 2;
    DateTime date = dict[EmpID][PayRateID];

显然你需要先检查Values是否存在于字典中

我的建议是，

class Employee
{
   public int EmployeeID {get;set;}
   public DateTime Date {get;set;}
   public int PayID {get;set;}
}
class MyDictionary
{
    private static Dictionary<int, List<Employee>> dict = new Dictionary<int, List<Employee>>();
    public static void Add(Employee obj)
    {
        if (dict.ContainsKey(obj.EmployeeID))
        {
            dict[obj.EmployeeID].Add(obj);
        }
        else
        {
            dict.Add(obj.EmployeeID, new List<Employee>() {obj });
        }
    }
    public static List<Employee> GetEmps(int key)
    {
        if (dict.ContainsKey(key))
            return dict[key];
        return null;
    }
}

可以遍历字典或搜索员工

MyDictionary.Add(new Employee() { EmployeeID = 1, PayID = 1 });
 MyDictionary.Add(new Employee() { EmployeeID = 1, PayID = 2 });
 MyDictionary.Add(new Employee() { EmployeeID = 2, PayID = 3 });
 MyDictionary.Add(new Employee() { EmployeeID = 3, PayID = 1 });
 foreach (Employee e in MyDictionary.GetEmps(1))
    Console.WriteLine(e.EmployeeID + " " + e.PayID);

如果您想要找到要删除的行，那么最好创建代表整行的MyValue。请记住，Dictionary不允许多次添加一个键。此外，如果您想找到行，那么您不需要将它们的值存储在不同的列表中，因为您很容易丢失哪个列表中的哪个值对应于哪个行。因此，最好以这样的方式存储要删除的行:

Dictionary<int, List<MyValue>> rowsToBeDeleted = new Dictionary<int, List<MyValue>> ();
class MyValue
{
  int EmpID;
  int PayID;
  DateTime Date;
}
rowsToBeDeleted.Add(123, new List<MyValue>);
rowsToBeDeleted[123].Add(123, 1, new DateTime(2011,8,31);
rowsToBeDeleted[123].Add(123, 2, new DateTime(2011,10,31);
rowsToBeDeleted.Add(1234, new List<MyValue>);
rowsToBeDeleted[1234].Add(1234, 1, new DateTime(2011,18,31); // month #18 - wow!
rowsToBeDeleted[1234].Add(1234, 2, new DateTime(2011,19,31);

现在，您可以使用EmployeeID作为键来查找要删除的行列表。

关于使用EmployeeID一次的经济性。当使用Dictionary<int, MyValue>时，您理所当然地拥有KeyValuePair<int, MyValue>，因为Dictionary实际上是KeyValuePair结构的集合。因此，如果你不想在类中创建新类型或存储另一个int值，可以尝试使用它。

然而，我认为将int添加到MyValue中并不是什么大问题-对主集合进行一些反向引用总是有用的，并且与指针类型相比，int相当小。但是，您将更方便地使用MyValues，而不是到处传递KeyValuePairs或MyValue + int。

谁知道这是怎么回事?

   arrEmpID.Add(1);
    arrEmpID.Add(1);
    arrEmpID.Add(2);
    arrEmpID.Add(2);
    arrPay.Add(1);
    arrPay.Add(1);
    arrPay.Add(2);
    arrPay.Add(2);

    DateTime dt = DateTime.Now;
    DateTime dt1 = DateTime.Now.AddMinutes(1);
    DateTime dt2 = DateTime.Now.AddMinutes(1);
    DateTime dt3 = DateTime.Now.AddMinutes(1);
    arrPayID.Add(dt);
    arrPayID.Add(dt1);
    arrPayID.Add(dt2);
    arrPayID.Add(dt3);
    EmpIDs = (int[])arrEmpID.ToArray(typeof(int));
    Dates = (DateTime[])arrPayID.ToArray(typeof(DateTime));
    PayIDs = (int[])arrPay.ToArray(typeof(int));
for (int i = 0; i < EmpIDs.Length; i++)
    {
        if (!(d.ContainsKey(EmpIDs[i])))
        {
            List<int> values = new List<int>();
            List<DateTime> ldt = new List<DateTime>();
            d.Add(EmpIDs[i], values, ldt);
        }
        d[EmpIDs[i]].lst.Add(PayIDs[i]);
        d[EmpIDs[i]].lstdt.Add(Dates[i]);
    }
   foreach (int EmpID in d.Keys)
    {
        foreach (int pID in d[EmpID].lst) // I just missed out this values
        {
            sb.Append(pID);
            sb.AppendLine(" ");
        }
        foreach (DateTime dtTimes in d[EmpID].lstdt)  // I just missed out this values
        {
            sb1.Append(dtTimes.ToString("MMddyyyy"));
            sb1.AppendLine(" ");
        }
    }
    Label1.Text = sb.ToString();
    Label2.Text = sb1.ToString();

我的字典如下

public struct MyValue
{
    public List<int> lst;
    public List<DateTime> lstdt;
}
public class MyDictionary : Dictionary<int, MyValue>
{
    public void Add(int key, List<int> lst1, List<DateTime> lstDt1)
    {
        MyValue v1 = new MyValue();
        v1.lst = lst1;
        v1.lstdt = lstDt1;
        this.Add(key, v1);
    }
}

相关文章：

最新信息: