Question

在我开始研究的新项目中，我自己学习c＃，

其中一个方法接受List<string>类型数据，作为参数传入。我想知道，现在......需要两个这些列表，两种类型的数据或两个组，

仅为此示例，假设我有一个专业和缺点，或者.. 女孩和男孩，

这些实际上是2个单独的元素或对象列表，我需要传入，作为参数，我希望它作为一个数据类型传递，然后，在方法内部我将负责数据列表的分离，所以...而不是几个List对象，我想（为在那里，Dictionary适合......）

虽然我只有一个元素（一个项目......每个都是List），但是我需要传递的数据类型

我该怎么做才能得到这个结果？

我会试着说明一下：

List<string> classGirls = new List<string>();
List<string> classBoys = new List<string>();

for source中的eace项目......从源

加载

已完成列表女孩+列表男孩如何将它们作为一个字典传递给他们虽然知道你只会有一个女孩和一个男孩ListObjects？

public bool foundAMatch( string Lookup, List<string> G , List<string> B){
{
    var firstGirl = G.ElementAt(0);
    var firstBoy = B.ElementAt(0);

    return firstGirl == Lookup && firstBoy !=Lookup ;
}

相反，我需要它像

  public bool foundAmatch(string Lookup, someDataType.... Kids)
  {
    var firstGirl = kids-girls <-- first entity in kids;
    var firstBoy = kids-boys <-- first entity in Kids; 

    return firstGirl == Lookup && firstBoy !=Lookup ;
  }

记住一些事情......关于数据的属性，它应该具有良好的性能......自然需要，尽管最重要的是，它应该适当/易于安排并适合使用循环进行排序和作为主题的迭代对所有类型的统计操作。

问题是，

你将如何实现逻辑，它是一个现有的数据类型......我在考虑？

如果不是，那么在这种场景中选择/制作数据类型会采用什么方法？

Answer 1

您可以使用继承轻松解决此问题：

public abstract class Person
{
    public string Name { get; private set; }  // The setter is private because we only have to set this name when we create an instance

    protected Person(string name)
    {
        Name = name;
    }
}

public class Male : Person
{
    public Male(string name) : base(name)  // This constructor calls the constructor of the class it inherits and passes on the same argument
}

public class Female : Person
{
    public Female(string name) : base(name)
}

public bool IsMatch(string needle, IEnumerable<Person> haystack)
{
    var firstGirl = haystack.OfType<Female>().FirstOrDefault();
    var firstBuy = haystack.OfType<Male>().FirstOrDefault();
    return firstGirl != null &&
           firstGirl.Name == needle &&
           firstBoy != null &&
           firstBoy.Name != needle;
}

编辑：

我非常喜欢扩展方法，所以我会写这样的方法：

public static class PersonExtensions
{
    public static bool IsMatch(this IEnumerable<Person> haystack, string needle)
    {
        // same method logic in here
    }
}

然后您可以使用：

var people = new List<Person>();
people.Add(new Male { Name = "Bob" });
people.Add(new Female { Name = "Mary" });
var isMatch = people.IsMatch("Jane");

EDIT2：

将性别作为Person类的属性可能更好：

public enum Sex
{
    Male,
    Female
}

public class Person
{
    public string Name { get; private set; }
    public Sex Gender { get; private set; }

    public Person(string name, Sex gender)
    {
        Name = name;
        Gender = gender;
    }
}

并将方法更改为：

var firstGirl = haystack.FirstOrDefault(p => p.Gender == Gender.Female);
var firstBoy = haystack.FirstOrDefault(p => p.Gender == Gender.Male);

Answer 2

获得一个集合的最佳方法是创建一个代表男孩和女孩的类。请找到以下示例：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private class Kid
        {
            public bool Gender { get; set; }
            public String Name { get; set; }
        }

        private List<Kid> kids;

        private void Form1_Load(object sender, EventArgs e)
        {
            // === Load data =================================================
            kids = new List<Kid>();
            kids.Add(new Kid { Name = "John", Gender = true });
            kids.Add(new Kid { Name = "Paul", Gender = true });
            kids.Add(new Kid { Name = "Jack", Gender = true });
            kids.Add(new Kid { Name = "Brenda", Gender = false });
            kids.Add(new Kid { Name = "Judith", Gender = false });
            kids.Add(new Kid { Name = "Sofia", Gender = false });

            Kid foundKid = foundAMatch("sofIa");
        }

        private Kid foundAMatch(string name)
        {
            var result = (from K in kids
                          where K.Name.ToLower() == name.ToLower() 
                          select K);

            if (result.Count() != 0)
                return result.First();
            else
                return null;
        }

        private Kid foundAMatch(string name, bool gender)
        {
            var result = (from K in kids
                          where K.Name.ToLower() == name.ToLower() && K.Gender == gender
                          select K);

            if (result.Count() != 0)
                return result.First();
            else
                return null;
        }

    }
}

数据类型适合于一对List <string>对象，作为一个容器来容纳</string>

2 个答案: