C#WCF - 发送自定义BindableDictionary <string,customobject>()通过电线</string,customobject>

时间:2010-07-30 10:59:31

标签: wcf callback

修改

  • 好的,我已经知道了,它不可序列化.........所以,我该如何进行序列化呢?

方案

  1. 我有一个自定义的BindableDictionary 我用来绑定网格 控制自动更新 底层的网格 数据源更改。
  2. 我现在想扩展我的申请 使用WCF,这样的时候 服务器端已完成更新 新的BindableDictionary 值,它可以传递这个字典 对客户来说,反过来可以 在客户端上执行更新 GUI。
  3. 问题

    • 如何发送此自定义 电线上的BindableDictionary?
    • 实现此目的的最佳方法是什么?
    • 我询问实现方法的原因是我看到的每个例子都是Duplex,Callbacks或Observer模式,用于“将我的数据”推送到客户端,只使用了一个传递字符串的例子,它非常原始 - 每当我更新示例以使用我的自定义BindableDictionary时,我都无法使其工作。
    • 我错过了什么吗?

    BindableDictionary

        public class BindableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IBindingList
        {
            private Dictionary<TKey, TValue> source = new Dictionary<TKey, TValue>();
    
            void IBindingList.AddIndex(PropertyDescriptor property) { }
            object IBindingList.AddNew() { throw new NotImplementedException(); }
            bool IBindingList.AllowEdit { get { return false; } }
            bool IBindingList.AllowNew { get { return false; } }
            bool IBindingList.AllowRemove { get { return false; } }
            void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction) { }
            int IBindingList.Find(PropertyDescriptor property, object key) { throw new NotImplementedException(); }
            bool IBindingList.IsSorted { get { return false; } }
            void IBindingList.RemoveIndex(PropertyDescriptor property) { }
            void IBindingList.RemoveSort() { }
            ListSortDirection IBindingList.SortDirection { get { return ListSortDirection.Ascending; } }
            PropertyDescriptor IBindingList.SortProperty { get { return null; } }
            bool IBindingList.SupportsChangeNotification { get { return true; } }
            bool IBindingList.SupportsSearching { get { return false; } }
            bool IBindingList.SupportsSorting { get { return false; } }
            int System.Collections.IList.Add(object value) { throw new NotImplementedException(); }
            void System.Collections.IList.Clear() { Clear(); }
            bool System.Collections.IList.Contains(object value) { if (value is TKey) { return source.ContainsKey((TKey)value); } else if (value is TValue) { return source.ContainsValue((TValue)value); } return false; }
            int System.Collections.IList.IndexOf(object value) { return -1; }
            void System.Collections.IList.Insert(int index, object value) { throw new NotImplementedException(); }
            bool System.Collections.IList.IsFixedSize { get { return false; } }
            bool System.Collections.IList.IsReadOnly { get { return true; } }
            void System.Collections.IList.Remove(object value) { if (value is TKey) { Remove((TKey)value); } }
            void System.Collections.IList.RemoveAt(int index) { throw new NotImplementedException(); }
            object System.Collections.IList.this[int index] { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } }
    
            private ListChangedEventHandler listChanged;
    
            event ListChangedEventHandler IBindingList.ListChanged
            {
                add { listChanged += value; }
                remove { listChanged -= value; }
            }
    
            protected virtual void OnListChanged(ListChangedEventArgs e)
            {
                var evt = listChanged;
    
                if (evt != null) evt(this, e);
            }
    
            public void Add(TKey key, TValue value)
            {
                source.Add(key, value);
    
                OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
            }
    
            public bool Remove(TKey key)
            {
                if (source.Remove(key))
                {
                    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
    
                    return true;
                }
    
                return false;
            }
    
            public TValue this[TKey key]
            {
                get
                {
                    return source[key];
                }
                set
                {
                    source[key] = value;
    
                    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
                }
            }
    
            void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
            {
                ((ICollection<KeyValuePair<TKey, TValue>>)source).Add(item);
    
                OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
            }
    
            bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
            {
                if (((ICollection<KeyValuePair<TKey, TValue>>)source).Remove(item))
                {
                    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
    
                    return true;
                }
    
                return false;
            }
    
            public bool ContainsKey(TKey key) { return source.ContainsKey(key); }
            public ICollection<TKey> Keys { get { return source.Keys; } }
            public bool TryGetValue(TKey key, out TValue value) { return source.TryGetValue(key, out value); }
            public ICollection<TValue> Values { get { return source.Values; } }
            public void Clear() { source.Clear(); }
            bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) { return ((ICollection<KeyValuePair<TKey, TValue>>)source).Contains(item); }
            void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) { ((ICollection<KeyValuePair<TKey, TValue>>)source).CopyTo(array, arrayIndex); }
            public int Count { get { return source.Count; } }
            bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly { get { return ((ICollection<KeyValuePair<TKey, TValue>>)source).IsReadOnly; } }
            public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() { return source.GetEnumerator(); }
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
            bool ICollection.IsSynchronized { get { return false; } }
            object ICollection.SyncRoot { get { return null; } }
            void ICollection.CopyTo(Array array, int arrayIndex) { ((ICollection)source).CopyTo(array, arrayIndex); }
        }
    

2 个答案:

答案 0 :(得分:2)

如果您的BindableDictionary有一组特定的键/值,则可以设置自己的“数据传输”对象,以反映这些值:

[DataContract]
public class MyDTOType
{
   [DataMember]   
   public (keytype) Key { get; set; }
   [DataMember]   
   public (valuetype) Value { get; set; }
}

然后有一个包含List<MyDTOType>的DTO对象:

[DataContract]
public class MyDTOList
{
   [DataMember]   
   public List<MyDTOType> ListOfKeyValues { get; set; }
}

现在,只要您的MyDTOType类中的(keytype)和(valuetype)具有可序列化类型,就可以在WCF中穿越线路:

[ServiceContract]
interface IMyService
{
    [OperationContract]
    public MyDTOList GetAllValues(int someCriteria);
}

并且您需要找到一种处理方式的最后一步是将BindableDictionary<TKey, TValue)转换为MyDTOList,其中包含MyDTOType个实例的列表,其中包含{{1}的键}}类型和TKey类型的值。您可以使用类似AutoMapper的内容来逐个项目地处理此转换。

答案 1 :(得分:0)

答案是字典不可序列化。 我现在设计了一个可序列化的字典。