• estimation只是一个开始,不是结束.好的estimation不是developer估的好,还要靠BA大人们来管理scope,不然就算developer牛成马了,estimation还是一坨.
• 相对于给出一个精确的绝对值来说,维护内在的相对关系更重要,一致性为王.
• story写得不好,再estimate也是枉费功夫.
• 不要总是关注story的大小,把一些story加起来构成一个完整feature的大小也很重要.对于客户来说,他们往往关注在feature级别.
• 一个feature的大小,往往还取决于BA对它写了多少了个story.
• 没有"一天"的story,请慎用最乐观的情况.
• 需求不明应对方案一,拒绝estimate,直到有人给你讲明白到你觉得可以estimate的时候为止.
• 需求不明应对方案二,做出假设,并且记录在案.但是不要做出明显不合理的假设.并要注意开发过程中对于当时假设的校验,BA要负责维护这些假设.
• change request要落到实处.至少要把假设被打破,estimation需要重新修改的情况,放到明处.
• 不要给出"10"作为估计.10不是estimation,10代表"你不知道".PM也不要天真的拿10去做release planning.
• 正常的story不会太大也不会太小,而且大部分的大小是相对一致的.estimation往往都是一些中间的数.
• story的大小,与参与的系统组建数量有关(纯客户端,客户端服务器,客户端服务器加新的表)
• story的大小,与变化点的数量有关(如果情况a,则如何如何,如果情况b,则如何如何)
• story的大小,与在同一块区域,过往story的复杂度有关(在一个复杂功能区域上添加新的业务规则,要难于新写一块)
• 学习新技术的时间,不明集成点,测试时间等,不便分配到每个story中.倾向于不添加到estimation中.而是以risk factor等其他形式体现出来.
• 砍掉的story,总是那些estimation高,实现起来容易的.留下的story,总是那些estimation低,难于实现的.想想吧,我们该如何做.不要抱有侥幸心理.estimate的时候,就要考虑如果这个story被砍掉了,你觉得你亏不亏.
• 拒绝用ideal hour做estimation,最小的单位不能小于半天(最好是一天)
• 在没有得到更多信息的情况下,re-estimate等价于对开发人员的连夜审讯,你必将被屈打成招.拒绝做这样无谓的事情.
• 好的BA,好的BA,好的BA....(好的标准是什么?温柔,贤惠,善解人意...)

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class Item {
  private Set<Bid> bids = new HashSet<Bid>();
}

public class Bid {
  private User bidder;
  private int amount;
}

    Bid currentMaxBid = itemDAO.getMaxBid(itemId);
    Item item = itemDAO.findById(itemId, true);
    if (currentMaxBid != null && bidAmount <= currentMaxBid.getAmount()) {
        throw new BizException("Bid too low.");
    }
    Bid newBid = new Bid(this, bidder, bidAmount);
    item.getBids().add(bid);
    itemDao.save(item);

public class Item {
  public Bid placeBid(User bidder, int bidAmount, Bid currentMaxBid) {
     if (currentMaxBid != null && bidAmount <= currentMaxBid.getAmount()) {
        throw new BizException("Bid too low.");
     }
     Bid newBid = new Bid(this, bidder, bidAmount);
     bids.add(newBid);
     return newBid;
  }
}

public class Item {
  private RichSet<Bid> bids = new DefaultRichSet<Bid>();
  public Bid placeBid(User bidder, int bidAmount) {
     Bid currentMaxBid = bids.max("amount");
     if (currentMaxBid != null && bidAmount <= currentMaxBid.getAmount()) {
        throw new BizException("Bid too low.");
     }
     Bid newBid = new Bid(this, bidder, bidAmount);
     bids.add(newBid);
     return newBid;
  }
}

public class ItemRepository {
  private RichList<Item> items
  public ItemRepository(RichList<Item> items) {
    this.items = items;
  }
}

public class ItemRepository {
  public void addItem(String name) {
    if (items.find("name").eq(name).size() > 0) {
       throw new BizException("name duplicated");
    }
    Item item = new Item(name);
    items.add(item);
    return item;
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class Employee {
    private Set<Task> tasks = new HashSet<Task>();
}

public class Task {
    private String name;
    private Employee owner;
    private Date startTime;
    private Date endTime;
}

public class Employee {
    private Set<Task> tasks = new HashSet<Task>();
    public Set<Task> getProcessingTask() {
       ...
    }
}

public class TaskDAO {
   public Set<Task> getProcessingTasks(Employee employee) {
      ...//sql
   }
}

@Entity
public class Employee {
    @OneToMany
    private Set<Task> tasks = new HashSet<Task>();
    public Set<Task> getProcessingTask() {
       ...
    }
}

@Entity
@Configurable
public class Employee {
    private TaskDao dao;
    public Set<Task> getProcessingTask() {
        return dao.getProcessingTask(this);
    }
    public void setTaskDao(TaskDao dao) {
        this.dao = dao;
    }
}

public class Employee {
    private RichSet<Task> tasks = new DefaultRichSet<Task>();
    public RichSet<Task> getProcessingTasks() {
        return tasks.find("startTime").le(new Date()).find("endTime").isNull();
    }
...
}

public interface RichSet<T> extends Set<T> {
    Finder<RichSet<T>> find(String expression);
    int sum(String expression);
}

<hibernate-mapping default-access="field" package="net.sf.ferrum.example.domain">
    <class name="Employee">
        <tuplizer entity-mode="pojo" class="net.sf.ferrum.RichEntityTuplizer"/>
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="salary"/>
        <many-to-one name="department"/>
        <set name="tasks" cascade="all" inverse="true" lazy="true">
            <key/>
            <one-to-many class="Task" />
        </set>
    </class>
</hibernate-mapping>

public class RichEntityTuplizer extends PojoEntityTuplizer {
    public RichEntityTuplizer(EntityMetamodel entityMetamodel, PersistentClass mappedEntity) {
        super(entityMetamodel, mappedEntity);
    }

    protected Setter buildPropertySetter(final Property mappedProperty, PersistentClass mappedEntity) {
        final Setter setter = super.buildPropertySetter(mappedProperty, mappedEntity);
        if (!(mappedProperty.getValue() instanceof org.hibernate.mapping.Set)) {
            return setter;
        }
        return new Setter() {
            public void set(Object target, Object value, SessionFactoryImplementor factory) throws HibernateException {
                Object wrappedValue = value;
                if (value instanceof Set) {
                    HibernateRepository repository = new HibernateRepository();
                    repository.setSessionFactory(factory);
                    wrappedValue = new HibernateRichSet((Set) value, repository, getCriteria(mappedProperty, target));
                }
                setter.set(target, wrappedValue, factory);
            }

            public String getMethodName() {
                return setter.getMethodName();
            }

            public Method getMethod() {
                return setter.getMethod();
            }
        };
    }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• Marshal.GetIUnknownForObject(attachment.MAPIOBJECT)
• Marshal.QueryInterface(pUnk, ref IID_IMAPIProp, out pMAPIPropObj); // Guid IID_IMAPIProp = new Guid("{00020303-0000-0000-C000-000000000046}");
• pMAPIProp->GetProps((LPSPropTagArray)props, MAPI_UNICODE, &count, &propValue); // ULONG props[] = {1, 0x3712001E}; // property tag for content id

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    public interface IComObject : IDisposable
    {
        bool Release();
    }

    public abstract class ComObject : IComObject
    {
        private bool shouldRelease = true;
        public abstract void Dispose();

        public ComObject()
        {
            ComObjectsPool.PutIn(this);
        }

        public bool Release()
        {
            if (shouldRelease)
            {
                Dispose();
                return true;
            }
            return false;
        }

        public bool ShouldRelease
        {
            get { return shouldRelease; }
            set { shouldRelease = value; }
        }
    }

    public static class ComObjectsPool
    {
        private static readonly List<IComObject> comObjects = new List<IComObject>();

        public static void PutIn(IComObject comObject)
        {
            comObjects.Add(comObject);
        }

        public static void ReleaseAll()
        {
            List<IComObject> unreleasedComObjects = new List<IComObject>();
            foreach (IComObject comObject in comObjects)
            {
                if (!comObject.Release())
                {
                    unreleasedComObjects.Add(comObject);
                }
            }
            comObjects.Clear();
            comObjects.AddRange(unreleasedComObjects);
        }
    }

    public class AdaptedShape : ComObject, IShape
    {
        private readonly Shape shape;

        public AdaptedShape(Shape shape)
        {
            this.shape = shape;
        }

        public override void Dispose()
        {
            Marshal.ReleaseComObject(shape);
        }
    }

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    public interface IBlock
    {
        string Quote();
        void Append(char c);
        bool ShouldAppendQuotedBlock(char c);
    }

    public abstract class NestedBlock : IBlock
    {
        private readonly NestedBlock parent;
        private readonly List<IBlock> blocks;
        private IBlock currentBlock;

        public NestedBlock(NestedBlock parent)
        {
            this.parent = parent;
            blocks = new List<IBlock>();
        }

        public virtual string Quote()
        {
            StringBuilder stringBuilder = new StringBuilder();
            foreach (IBlock block in blocks)
            {
                stringBuilder.Append(block.Quote());
            }
            return stringBuilder.ToString();
        }

        public abstract void Append(char c);
        public abstract bool ShouldAppendQuotedBlock(char c);

        protected NestedBlock Parent
        {
            get { return parent; }
        }

        protected IBlock CurrentBlock
        {
            get { return currentBlock; }
        }

        public void AppendBlock(IBlock block)
        {
            blocks.Add(block);
            currentBlock = block;
        }
    }

    public class QuotedBlock : NestedBlock
    {
        private readonly IQuoteStrategy quoteStrategy;
        private readonly char expectedQuote;

        public QuotedBlock(IQuoteStrategy quoteStrategy, char expectedQuote, NestedBlock parent) : base(parent)
        {
            this.quoteStrategy = quoteStrategy;
            this.expectedQuote = expectedQuote;
            AppendBlock(new RootBlock(quoteStrategy));
        }

        public override string Quote()
        {
            return expectedQuote + quoteStrategy.Quote(base.Quote()) + expectedQuote;
        }

        public override void Append(char c)
        {
            if (c == expectedQuote)
            {
                Parent.AppendBlock(new UnquotedBlock());
            }
            else
            {
                CurrentBlock.Append(c);
            }
        }

        public override bool ShouldAppendQuotedBlock(char c)
        {
            return false;
        }
    }

    public class UnquotedBlock : IBlock
    {
        private readonly StringBuilder stringBuilder = new StringBuilder();

        public string Quote()
        {
            return stringBuilder.ToString();
        }

        public void Append(char c)
        {
            stringBuilder.Append(c);
        }

        public bool ShouldAppendQuotedBlock(char c)
        {
            return IsQuotationMark(c);
        }

        private static bool IsQuotationMark(char c)
        {
            if (c == '"')
            {
                return true;
            }
            return c == '\'';
        }
    }

   public class RootBlock : NestedBlock
    {
        private readonly IQuoteStrategy quoteStrategy;

        public RootBlock(IQuoteStrategy quoteStrategy) : base(null)
        {
            this.quoteStrategy = quoteStrategy;
            AppendBlock(new UnquotedBlock());
        }

        public override void Append(char c)
        {
            if (CurrentBlock.ShouldAppendQuotedBlock(c))
            {
                AppendBlock(new QuotedBlock(quoteStrategy, c, this));
            }
            else
            {
                CurrentBlock.Append(c);
            }
        }

        public override bool ShouldAppendQuotedBlock(char c)
        {
            throw new ViScriptSystemException();
        }
    }

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

BinaryServerFormatterSinkProvider serverFormatter = new BinaryServerFormatterSinkProvider();
            serverFormatter.TypeFilterLevel = TypeFilterLevel.Full;
            Hashtable properties = new Hashtable();
            properties.Add("portName", "thoughtworks");
            IpcChannel channel = new IpcChannel(properties, null, serverFormatter);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• Drag drop not working when used in outlook
• Topmost is not "topmost" when change screen resolution
• Context menu overlapped by transparent window sometime
• Click through, underlying window can get the mouse click event [*] even it do not have mouse capture
• focus could remain in collapsed visual element

• Serialize IList when used in outlook 2007 will cause .NET runtime fatal execution error

• commandbar buttons disapper sometime when using word as email editor
• outlook popped up every time when we change html body (word as email editor)

• Send mail to multiple recipients using word as email editor
• Drag drop object from wpf application to the email composer "to" field will throw COMException

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

            GridViewColumn gvcName = new GridViewColumn();
            gvcName.Header = "Name";
            DataTemplate nameTemplate = new DataTemplate();
            FrameworkElementFactory nameFactory = new FrameworkElementFactory(typeof(ContactPropertyLabel));
            Binding binding = new Binding("Name");
            binding.Mode = BindingMode.TwoWay;
            nameFactory.SetBinding(ContentProperty, binding);
            nameTemplate.VisualTree = nameFactory;
            gvcName.CellTemplate = nameTemplate;
            gvContactList.Columns.Add(gvcName);

public class Contact : DependencyObject
    {
public static DependencyProperty NameProperty = DependencyProperty.Register("Name", typeof (string), typeof (Contact));

        public string Name
        {
            get { return (string) GetValue(NameProperty); }
            set { SetValue(NameProperty, value); }
        }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

string path = @"The Path To The Application";
Process process = Process.Start(path);

Thread.Sleep(1000);
AutomationElement aeMainWindow = AutomationElement.FromHandle(process.MainWindowHandle);

AutomationElement aeHelloButton = aeMainWindow.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Button));

InvokePattern ipHelloButton = (InvokePattern) aeHelloButton.GetCurrentPattern(InvokePattern.Pattern);
ipHelloButton.Invoke();

AutomationElement aeHelloTextBox = aeMainWindow.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Edit));

TextPattern tpHelloTextBox = (TextPattern) aeHelloTextBox.GetCurrentPattern(TextPattern.Pattern);
string text = tpHelloTextBox.DocumentRange.GetText(-1);

Automation.AddAutomationEventHandler(WindowPattern.WindowClosedEvent, aeMainWindow, TreeScope.Element, HandleMainWindowClose);
private static void HandleMainWindowClose(object sender, AutomationEventArgs e)
{
  Console.WriteLine("Main Window Closed");
}

process.Kill();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public interface View {
	public void setText(String text);
	public void addActionListener(ActionListener actionListener);
}

public class Presenter {
	public Presenter(final View view) {
		view.addActionListener(new ActionListener() {
			public void actionPerformed() {
				view.setText("Hello");
			}
		});
	}
}

@Test
public void test_click_button_should_set_text_hello() {
		Mockery mockery = new Mockery();
		final View mockView = mockery.mock(View.class);
		final ActionListenerMatcher actionListenerMatcher = new ActionListenerMatcher();
		mockery.checking(new Expectations() {
			{
				one(mockView).addActionListener(
						with(actionListenerMatcher));
				one(mockView).setText("Hello");
			}
		});
		new Presenter(mockView);
		actionListenerMatcher.fireActionPerformed();
		mockery.assertIsSatisfied();
	}

public class ActionListenerMatcher extends BaseMatcher<ActionListener> {

	private ActionListener actionListener;

	public boolean matches(Object item) {
		actionListener = (ActionListener) item;
		return true;
	}

	public void fireActionPerformed() {
		actionListener.actionPerformed();
	}

	public void describeTo(Description description) {
	}

}

@Test
public void test_click_button_should_set_text_hello() {
		MockView mockView = new MockView();
		new Presenter(mockView);
		mockView.fireActionPerformed();
		Assert.assertEquals("Hello", mockView.getText());
	}

private class MockView implements View {
		private ActionListener actionListener;
		private String text;
		public void addActionListener(ActionListener actionListener) {
			this.actionListener = actionListener;
		}
		public void setText(String text) {
			this.text = text;
		}
		public String getText() {
			return text;
		}
		public void fireActionPerformed() {
			actionListener.actionPerformed();
		}
	}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class StubDbCommand
        {
            public object ExecuteScalar()
            {
                return "Hello";
            }
            public static DbCommand New()
            {
                return NDimple.Implement<DbCommand>(new StubDbCommand());
            }
        }
Console.WriteLine(StubDbCommand.New().ExecuteScalar());

public abstract class AbstractClass
        {
            protected abstract string AbstractMethod1();
            protected abstract string AbstractMethod2();
            public string InvokeAbstractMethod1()
            {
                return AbstractMethod1();
            }
        }

public abstract class StubAbstractClass : AbstractClass
        {
            protected override string AbstractMethod1()
            {
                return "Hello";
            }
            public static AbstractClass New()
            {
                return NDimple.Implement<AbstractClass>(typeof (StubAbstractClass));
            }
        }

Console.WriteLine(StubAbstractClass.New().InvokeAbstractMethod1());

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class Susan : ContainerBound
    {
        public void FallInLove()
        {
            Console.WriteLine("Susan has fallen in love with " + Get<Boy>().Name);
        }
    }

public class Lily : ContainerBound
    {
        public void Kiss()
        {
            Console.WriteLine("Lily is kissing {0}", Get<Boy>().Name);
        }
    }

public class Lucy : ContainerBound
    {
        public void Marry()
        {
            Console.WriteLine("Lucy is marrying " + Get<Boy>().Name);
        }
    }

Containers.GetContainerInContext<object>().Put(new GenericBoy("Van"));

Containers.GetContainerInContext<Lucy>().Put(new GenericBoy("Tom"));

Containers.GetContainerInContext<Lily>().Put(new GenericBoy("Joy"));

Containers.Close();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Tom tom = Void.GiveMe<Tom>();
Joy joy = Void.GiveMe<Joy>();
Void.UniverseOf<Lily>().Exist(tom);
Void.UniverseOf<Lucy>().Exist(joy);

Lily lily = Void.GiveMe<Lily>();
lily.Kiss();
Lucy lucy = Void.GiveMe<Lucy>();
lucy.Kiss();

public abstract class Girl : God
{
    public abstract string Name { get; }
    public void Kiss()
    {
        Boy boy = GiveMe<Boy>();
        Console.WriteLine("{0} is kissing {1}", Name, boy.Name);
    }
}

public abstract class God
{
    protected abstract T GiveMe<T>();
}

Lily lily = Void.GiveMe<Lily>();
Lucy lucy = Void.GiveMe<Lucy>();

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

        private static Assembly CurrentDomain_AssemblyResolve(object sender, 
 ResolveEventArgs args)
        {
            Assembly ayResult = null;
            string sShortAssemblyName = args.Name.Split(',')[0];
            Assembly[] ayAssemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (Assembly ayAssembly in ayAssemblies)
            {
                if (sShortAssemblyName == ayAssembly.FullName.Split(',')[0])
                {
                    ayResult = ayAssembly;
                    break;
                }
            }
            return ayResult;
        }

static YourClass()
{
  AppDomain.CurrentDomain.AssemblyResolve += 
new ResolveEventHandler(CurrentDomain_AssemblyResolve);
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师