C# 在WCF中发送自己的数据收集

我有自己的收集数据合同：

    [DataContract]
public class DzieckoAndOpiekun
{
    public DzieckoAndOpiekun() { }
    public DzieckoAndOpiekun(string dzImie, string dzNazwisko, string opImie, string opNazwisko)
    {
        this.DzieckoImie = dzImie;
        this.DzieckoImie = dzNazwisko;
        this.OpiekunImie = opImie;
        this.OpiekunNazwisko = opNazwisko;
    }

    /// <summary>
    /// Field for Dziecko's Surname
    /// </summary>
    private string dzieckoNazwisko;

    /// <summary>
    /// Field for Dziecko's Name
    /// </summary>
    private string dzieckoImie;

    /// <summary>
    /// Field for Opiekun's Surname
    /// </summary>
    private string opiekunNazwisko;

    /// <summary>
    /// Field for Opiekun's Name
    /// </summary>
    private string opiekunImie;

    /// <summary>
    /// Gets or sets the dziecko nazwisko.
    /// </summary>
    /// <value>The dziecko nazwisko.</value>
    [DataMember]
    public virtual string DzieckoNazwisko
    {
        get { return this.dzieckoNazwisko; }
        set { this.dzieckoNazwisko = value; }
    }

    /// <summary>
    /// Gets or sets the dziecko imie.
    /// </summary>
    /// <value>The dziecko imie.</value>
    [DataMember]
    public virtual string DzieckoImie
    {
        get { return this.dzieckoImie; }
        set { this.dzieckoImie = value; }
    }

    /// <summary>
    /// Gets or sets the opiekun nazwisko.
    /// </summary>
    /// <value>The opiekun nazwisko.</value>
    [DataMember]
    public virtual string OpiekunNazwisko
    {
        get { return this.opiekunNazwisko; }
        set { this.opiekunNazwisko = value; }
    }

    /// <summary>
    /// Gets or sets the opiekun imie.
    /// </summary>
    /// <value>The opiekun imie.</value>
    [DataMember]
    public virtual string OpiekunImie
    {
        get { return this.opiekunImie; }
        set { this.opiekunImie = value; }
    }
}

[DataContract]
public class DzieckoAndOpiekunCollection : IEnumerable<DzieckoAndOpiekun>, IList<DzieckoAndOpiekun>
{
    [DataMember]
    List<DzieckoAndOpiekun> collection = new List<DzieckoAndOpiekun>();

    [DataMember]
    public List<DzieckoAndOpiekun> Collection
    {
        get { return collection; }
        set { collection = value; }
    }

    public IEnumerator<DzieckoAndOpiekun> GetEnumerator()
    {
        return collection.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        throw new System.NotImplementedException();
    }

    public int IndexOf(DzieckoAndOpiekun item)
    {
        return collection.IndexOf(item);
    }

    public void Insert(int index, DzieckoAndOpiekun item)
    {
        collection.Insert(index, item);
    }

    public void RemoveAt(int index)
    {
        collection.RemoveAt(index);
    }

    public DzieckoAndOpiekun this[int index]
    {
        get
        {
            return collection[index];
        }
        set
        {
            collection[index] = value;
        }
    }

    public void Add(DzieckoAndOpiekun item)
    {
        this.collection.Add(item);
    }

    public void AddRange(IList<DzieckoAndOpiekun> collection)
    {
        this.collection.AddRange(collection);
    }

    public void Clear()
    {
        collection.Clear();
    }

    public bool Contains(DzieckoAndOpiekun item)
    {
        return collection.Contains(item);
    }

    public void CopyTo(DzieckoAndOpiekun[] array, int arrayIndex)
    {
        this.collection.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return this.collection.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(DzieckoAndOpiekun item)
    {
        return this.collection.Remove(item);
    }
}

[DataContract]
公共级DzieckoAndOpiekun
{
公共DzieckoAndOpiekun（）{}
公共DzieckoAndOpiekun（字符串dzImie、字符串dzNazwisko、字符串opImie、字符串opNazwisko）
{
this.DzieckoImie=dzImie；
this.DzieckoImie=dzNazwisko；
this.OpiekunImie=opImie；
this.opiekunanazwisko=opNazwisko；
}
/// 
///Dziecko姓氏字段
/// 
私人字符串Dzieckonazzwisko；
/// 
///Dziecko名字的字段
/// 
私有字符串dzieckoImie；
/// 
///奥皮肯姓氏字段
/// 
私人字符串Opiekunanazwisko；
/// 
///Opiekun名称的字段
/// 
私有字符串opiekunImie；
/// 
///获取或设置dziecko-nazwisko。
/// 
///dziecko-nazwisko。
[数据成员]
公共虚拟字符串Dzieckonazzwisko
{
获取{返回this.dzieckonazzwisko；}
设置{this.dzieckonazzwisko=value；}
}
/// 
///获取或设置dziecko imie。
/// 
///dziecko imie。
[数据成员]
公共虚拟字符串DzieckoImie
{
获取{返回this.dzieckoImie；}
设置{this.dzieckoImie=value；}
}
/// 
///获取或设置opiekun nazwisko。
/// 
///奥皮肯·纳兹维斯科。
[数据成员]
公共虚拟字符串opiekunanazwisko
{
获取{返回this.opiekunanazwisko；}
设置{this.opiekunNazwisko=value；}
}
/// 
///获取或设置opiekun imie。
/// 
///奥皮肯·伊米。
[数据成员]
公共虚拟字符串OpiekunImie
{
获取{返回this.opiekunImie；}
设置{this.opiekunImie=value；}
}
}
[数据合同]
公共类DzieckoAndOpiekunCollection:IEnumerable，IList
{
[数据成员]
列表集合=新列表（）；
[数据成员]
公共列表集合
{
获取{return collection；}
设置{collection=value；}
}
公共IEnumerator GetEnumerator（）
{
返回集合。GetEnumerator（）；
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator（）
{
抛出新系统。NotImplementedException（）；
}
公共国际指数（DzieckoAndOpiekun项目）
{
返回集合。索引（项目）；
}
公共作废插入（内部索引，DzieckoAndOpiekun项目）
{
收藏。插入（索引，项目）；
}
公共无效删除（整数索引）
{
收集、删除（索引）；
}
公共DzieckoAndOpiekun本[int索引]
{
得到
{
返回集合[索引]；
}
设置
{
集合[索引]=值；
}
}
公共作废添加（DzieckoAndOpiekun项目）
{
此.集合.添加（项）；
}
公共void AddRange（IList集合）
{
this.collection.AddRange（collection）；
}
公共空间清除（）
{
collection.Clear（）；
}
公共布尔包含（DzieckoAndOpiekun项目）
{
返回集合。包含（项目）；
}
public void CopyTo（DzieckoAndOpiekun[]数组，int-arrayIndex）
{
this.collection.CopyTo（array，arrayIndex）；
}
公共整数计数
{
获取{返回this.collection.Count；}
}
公共图书馆是只读的
{
获取{return false；}
}
公共厕所拆除（DzieckoAndOpiekun项目）
{
返回此。收藏。删除（项目）；
}
}

并在我的ServiceContract实施中使用它：

 public DzieckoAndOpiekunCollection GetChildAndOpiekunByFirstnameLastname(string firstname, string lastname)
    {
        DataTransfer.ChargeInSchoolEntities db = new DataTransfer.ChargeInSchoolEntities();
        DzieckoAndOpiekunCollection result = new DzieckoAndOpiekunCollection();
        if (firstname == null && lastname != null)
        {
            IQueryable<DzieckoAndOpiekun> resultV = from p in db.Dziecko
                                                    where lastname == p.Nazwisko
                                                    select new DzieckoAndOpiekun(
                                                   p.Imie,
                                                   p.Nazwisko,
                                                   p.Opiekun.Imie,
                                                   p.Opiekun.Nazwisko);
            List<DzieckoAndOpiekun> l = resultV.ToList();
            result.AddRange(l);
        }
        if (firstname != null && lastname != null)
        {
            IQueryable<DzieckoAndOpiekun> resultV = from p in db.Dziecko
                                                    where firstname == p.Imie && lastname == p.Nazwisko
                                                    select new DzieckoAndOpiekun(
                                                   p.Imie,
                                                   p.Nazwisko,
                                                   p.Opiekun.Imie,
                                                   p.Opiekun.Nazwisko);
            List<DzieckoAndOpiekun> l = resultV.ToList();
            result.AddRange(l);
        }
        if (firstname != null && lastname == null)
        {
            IQueryable<DzieckoAndOpiekun> resultV = from p in db.Dziecko
                                                    where firstname == p.Imie
                                                    select new DzieckoAndOpiekun(
                                                   p.Imie,
                                                   p.Nazwisko,
                                                   p.Opiekun.Imie,
                                                   p.Opiekun.Nazwisko);
            List<DzieckoAndOpiekun> l = resultV.ToList();
            result.AddRange(l);
        }
        return result;
    }

public DzieckoAndOpiekunCollection GetChildAndOpiekunByFirstnameLastname（string firstname，string lastname）
{
DataTransfer.ChargeInChootenties db=新的DataTransfer.ChargeInChootenties（）；
DzieckoAndOpiekunCollection结果=新的DzieckoAndOpiekunCollection（）；
if（firstname==null&&lastname！=null）
{
IQueryable resultV=来自p，单位为db.Dziecko
其中lastname==p.Nazwisko
选择新的DzieckoAndOpiekun(
p、 伊米，
p、 纳兹维斯科，
p、 奥皮肯·伊米，
p、 奥皮肯·纳兹维斯科）；
List l=resultV.ToList（）；
结果：添加范围（l）；
}
if（firstname！=null&&lastname！=null）
{
IQueryable resultV=来自p，单位为db.Dziecko
其中firstname==p.Imie&&lastname==p.Nazwisko
选择新的DzieckoAndOpiekun(
p、 伊米，
p、 纳兹维斯科，
p、 奥皮肯·伊米，
p、 奥皮肯·纳兹维斯科）；
List l=resultV.ToList（）；
结果：添加范围（l）；
}
if（firstname！=null&&lastname==null）
{
IQueryable resultV=来自p，单位为db.Dziecko
其中firstname==p.Imie
选择新的DzieckoAndOpiekun(
p、 伊米，
p、 纳兹维斯科，
p、 奥皮肯·伊米，
p、 奥皮肯·纳兹维斯科）；
List l=resultV.ToList（）；
结果：添加范围（l）；
}
返回结果；
}

我是否在创建自己的数据合同并发送时出错？我询问，因为我在使用方法时出错：/：

操作期间发生异常，导致结果无效。 检查InnerException是否存在异常

[DataContract]
public class DzieckoAndOpiekunCollection : 
    IEnumerable<DzieckoAndOpiekun>, IList<DzieckoAndOpiekun>
{
    [DataMember]
    List<DzieckoAndOpiekun> collection = new List<DzieckoAndOpiekun>();

    [DataMember]
    public List<DzieckoAndOpiekun> Collection
    {
        get { return collection; }
        set { collection = value; }
    }
...