小编Gaz*_*yer的帖子

有什么方法可以在我的课程中订阅某个事件时收到通知,或者我是否需要在方法中包含订阅/取消订阅,例如:

public class MyClass : ISomeInterface
{
     public event SomeEventHandler SomeEvent; //How do I know when something subscribes?

     private void OnSomeEventSubscription(SomeEventHandler handler)
     { 
          //do some work
     }

     private void OnSomeEventUnsubscription(SomeEventHandler handler)
     { 
          //do some work
     }
}

代替

public class MyClass : ISomeInterface
{
     private SomeEventHandler _someEvent;

     public void SubscribeToSomeEvent(SomeEventHandler handler)
     {
          _someEvent += handler;

          //do some work
     }

     public void UnsubscribeFromSomeEvent(SomeEventHandler handler)
     {
          _someEvent -= handler;

          //do some work
     }    
}

我问的原因是因为事件已经直接暴露在a上,ISomeInterface但是这个特定的实现需要知道什么时候订阅/取消订阅.

我有一个在运行时使用DuplexChannelFactory生成的WCF代理.

如何仅在给定DuplexChannelFactory返回的服务接口的情况下访问绑定信息？

我可以通过转换到IClientChannel获得大多数东西,但我似乎无法在那里找到绑定信息.我能得到的最接近的是IClientChannel.RemoteAddress,它是一个端点,但似乎也没有绑定信息.: - /

我正在阅读这篇关于无锁线程同步的MSDN文章.这篇文章似乎推断,只要你在访问共享变量之前输入一个锁,那么这些变量将是最新的(至少在.Net 2.0中).

我想到这是怎么可能的？.Net中的锁只是所有线程在访问内存之前检查的任意对象,但锁本身并不知道正在访问的内存位置.

如果我有一个线程更新变量,甚至整个内存块,那么当进入/退出锁时,这些更新如何保证从CPU缓存中刷新？所有内存访问是否在锁内有效地变为易失性？

我正在从二进制流解码通信消息.我根据已到达的消息创建不同类型的消息对象.它们都来自基CommsMessage类型.一切都很好,花花公子.

在我的代码中,我需要对这些消息做出反应,所以我需要知道它是什么类型的消息.

目前我在做:

void ProcessIncomingMessage(CommsMessage msg)
{
    if (msg is MessageType1)
        return ProcessMessageType1(msg as MessageType1);

    if (msg is MessageType2)
        return ProcessMessageType2(msg as MessageType2);

    //etc
}

我想知道比较这些类型的性能成本是什么,以及我是否应该MessageType在基类中包含属性.然后我可以这样做:

void ProcessIncomingMessage(CommsMessage msg)
{
    switch (msg.MessageType)
    {
         case MessageType.Type1:  return ProcessMessageType1(msg as MessageType1);
         case MessageType.Type2:  return ProcessMessageType2(msg as MessageType2);

         //etc
    }
}

是的,这是不成熟的优化,我可能会担心无关紧要的细节,但我是那种喜欢知道幕后发生了什么的编码员,因此想知道两者之间的性能差异.我想我对我的C++背景中的类型比较存在偏见,其中RTTI引入了开销,并且只是想知道.Net是否有任何相似之处.

在调试时,我有时会发现需要在监视窗口中比较对象引用,以查看两个变量是否实际引用了同一个对象.

使用C++和指针这很容易,但有没有办法用C#引用呢？

我试图用XmlSerializer做一个非常简单的序列化:

public struct XmlPerson
{
    [XmlAttribute] public string Id   { get; set; }
    [XmlAttribute] public string Name { get; set; }
}

public class GroupOfPeople
{
    private Dictionary<string, string> _namesById = new Dictionary<string, string>();

    //pseudo property for serialising dictionary to/from XML
    public List<XmlPerson> _XmlPeople
    {
        get
        {
            var people = new List<XmlPerson>();
            foreach (KeyValuePair<string, string> pair in _namesById )
                people.Add(new XmlPerson() { Id = pair.Key, Name = pair.Value });

            return people;
        }
        set
        {
            _namesById.Clear();
            foreach (var person in value) …

我有一个WCF服务,刚刚为业务对象创建了一个DTO.

我的问题是在哪里放置两者之间的映射？

A)在DTO？

public class PersonDTO
{
    [DataMember] public string Id              { get; set; }
    [DataMember] public string Name            { get; set; }

    public void CloneFrom(Person p)
    {
        Id   = p.Id;
        Name = p.Name;
    }

    public void Populate(Person p)
    {
        p.Id   = Id;
        p.Name = Name;
    }
}

要么

B)在业务对象中？

public class Person
{
    public string Id              { get; set; }
    public string Name            { get; set; }

    public void CloneFrom(PersonDTO dto)
    {
        Id   = dto.Id;
        Name = dto.Name;
    } …

我正在设计一个执行长时间运行任务的类.我想出的第一个设计是:

public TaskHandle DoSomethingAsync(DoSomethingCompleteCallback completedCallback);
public void       CancelDoSomething(TaskHandle handle);

这简单而简洁.但是,我想知道我是否应该将其作为我一直在阅读的标准.Net异步模式之一来实现？

APM:

public IAsyncResult BeginDoSomething(AsyncCallback completedCallback, Object stateObject);
public void         EndDoSomething(IAsyncResult asyncResult);

EAP:

public void  DoSomethingAsync(string param, object userState);
public event DoSomethingCompletedEventHandler DoSomethingCompleted;

IMO这些似乎使界面变得复杂,除了作为其他.Net开发人员可识别的模式之外没有任何实际优势.APM要求客户端代码始终在其completedCallback中调用EndDoSomething(),并且EAP需要单独订阅已完成的事件.

如果有的话,使用我缺少的标准模式有什么好处？

我有一堆组合，它们都共享相同的可用选项。这些选择在从我的 ViewModel 公开的集合中提供。一切都很好，花花公子。

我现在希望对这些选择进行排序，因此我决定ICollectionView从我的 ViewModel公开 an而不是我通常的ReadonlyObservableCollection<T>，并在我的 ViewModel 中对集合视图进行排序。

class EditStuffViewModel : ViewModelBase
{
    public EditStuffViewModel (ObservableCollection<Choice> choices)
    {
        Choices = new CollectionViewSource() { Source = choices }.View;
        Choices.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Ascending));
    }

    public ICollectionView Choices
    {
        get;
        private set;
    }

    //snip other properties
}

这一切都很好，只是现在我所有的组合现在都同步了他们的选择。

这不是我想要的。我希望共享选择，但选择要与其正常绑定。我想我知道我的 CollectionView 正在跟踪选择，但我认为这是为每个控件选择的行为。

我已经尝试明确设置IsSynchronizedWithCurrentItem="False"我的组合，这成功地将它们解耦，但是我的绑定SelectedItem从未在组合中选择（调用了 ViewModel 的绑定 getter，但从未选择结果）。选择一个项目似乎可以正确更新我的 ViewModel 的 setter。

我显然错过了 CollectionView 应该如何工作的基本知识。任何人都可以启发我吗？

编辑：我不好，这确实适用于IsSynchronizedWithCurrentItem="False". 详情请看我的回答。

干杯。

默认情况下,引用类型数组初始化,所有引用都为null.

是否有任何语法技巧来使用新的默认对象初始化它们？

例如

public class Child
{
}

public class Parent
{
    private Child[] _children = new Child[10];

    public Parent()
    {
        //any way to negate the need for this?
        for (int n = 0; n < _children.Length; n++)
           _children[n] = new Child();
    }
}