首页 > 其他 > 详细

[tfs] workitemtracking source code

时间：2014-03-11 21:04:19      阅读：782      评论：0      收藏：0      [点我收藏+]
在编程时经常会遇到一些错误，例如，http://msdn.microsoft.com/en-us/library/microsoft.teamfoundation.workitemtracking.client.fieldstatus.aspx 上面所列出的错误，简单的通过描述无法确认真的问题所在，那么你就需要查看server内部是如何实现的。

namespaceMicrosoft.TeamFoundation.WorkItemTracking.Client
{
    usingMicrosoft.TeamFoundation;
    usingMicrosoft.TeamFoundation.Client;
    usingMicrosoft.TeamFoundation.Common;
    usingMicrosoft.TeamFoundation.WorkItemTracking.Client.DataStore;
    usingMicrosoft.TeamFoundation.WorkItemTracking.Proxy;
    usingSystem;
    usingSystem.Collections;
    usingSystem.Collections.Generic;
    usingSystem.Globalization;
    usingSystem.IO;
    usingSystem.Reflection;
    usingSystem.Runtime.InteropServices;
    usingSystem.Threading;
    usingSystem.Xml;
 
    publicsealed classWorkItem : IRevisionInternal
    {
        internalconst intc_revisionHistory = -4;
        internalconst intc_revisionLatest = -3;
        internalconst intc_revisionNull = -1;
        internalconst intc_revisionUpdate = -2;
        privateDateTime? m_asof;
        privateAttachmentCollection m_attachments;
        privateint m_dataVersion;
        privatebool? m_dirty;
        privateFieldCollection m_fields;
        privateWorkItemFieldData m_fieldsData;
        privateint m_id;
        privateint m_index;
        privatebool m_IsUpdating;
        privateLinkCollection m_links;
        privateWorkItemLinkData m_linksData;
        privateWorkItemCollection m_list;
        privateint m_metadataVersion;
        privateOpenState m_openState;
        privateMicrosoft.TeamFoundation.WorkItemTracking.Client.Project m_project;
        privatebool? m_readonly;
        privateRevisionCollection m_revisions;
        privateWorkItemStore m_store;
        privateint m_tempId;
        privateWorkItemType m_type;
        privateWorkItemLinkCollection m_wlinks;
        privateWorkItemLinkCollection m_wlinksHistory;
        privatestatic int[] s_areaDependentFieldIds =new int[] { -12, -42, -43, -44, -45, -46, -47, -48, -49 };
        internalstatic int[] s_internallyCalculatedFieldIds =new int[] {
            -7, -12, -42, -43, -44, -45, -46, -47, -48, -49, -105, -50, -51, -52, -53, -54,
            -55, -56
         };
        privatestatic int[] s_iterationDependentFieldIds =new int[] { -50, -51, -52, -53, -54, -55, -56 };
        privatestatic ints_tempId = 0;
 
        publicevent WorkItemFieldChangeEventHandler FieldChanged;
 
        publicWorkItem(WorkItemType type)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, WorkItemType type)");
            if(type == null)
            {
                thrownew ArgumentNullException("type");
            }
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            this.m_store = type.Store;
            this.m_id = 0;
            this.m_tempId = Interlocked.Decrement(refs_tempId);
            this.m_openState = OpenState.New;
            this.m_readonly =false;
            this.InitNew(type);
            this.ApplyRules();
            this.m_dirty =true;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemCollection list, intindex)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            this.m_store = list.Store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            this.m_id = list.GetId(index);
            this.m_tempId =this.m_id;
            this.m_list = list;
            this.m_index = index;
            this.m_openState = OpenState.Queried;
            if(!list.Query.IsBatchReadMode)
            {
                this.m_asof =new DateTime?(list.Query.AsOfUTC);
            }
        }
 
        internalWorkItem(WorkItemStore store, intid)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, int id)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            if(id <= 0)
            {
                thrownew ArgumentOutOfRangeException("id");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            this.m_id = id;
            this.m_tempId = id;
            this.LoadWorkItem(id, 0,null);
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemStore store, System.Uri uri)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, Uri uri)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            if(!this.IsValidUri(uri))
            {
                thrownew ArgumentException("uri");
            }
            ArtifactId artifact =this.GetArtifact(uri);
            this.m_id = Convert.ToInt32(artifact.ToolSpecificId, CultureInfo.InvariantCulture);
            this.m_tempId =this.m_id;
            this.LoadWorkItem(this.m_id, 0,null);
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemStore store, intid, DateTime at)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, int id, DateTime at)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            if(id <= 0)
            {
                thrownew ArgumentOutOfRangeException("id");
            }
            DateTime time = store.ConvertToUniversalTime(at);
            if((time < newDateTime(0x76c, 1, 1)) || (time >= DateTime.MaxValue))
            {
                thrownew ArgumentOutOfRangeException("at");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            this.m_id = id;
            this.m_tempId = id;
            this.LoadWorkItem(id, 0,new DateTime?(time));
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemStore store, intid, int revision)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, int id, int revision)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            if(id <= 0)
            {
                thrownew ArgumentOutOfRangeException("id");
            }
            if(revision <= 0)
            {
                thrownew ArgumentOutOfRangeException("revision");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            this.m_id = id;
            this.m_tempId = id;
            this.LoadWorkItem(id, revision,null);
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemStore store, System.Uri uri, DateTime at)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, Uri uri, DateTime at)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            DateTime time = store.ConvertToUniversalTime(at);
            if((time < newDateTime(0x76c, 1, 1)) || (time >= DateTime.MaxValue))
            {
                thrownew ArgumentOutOfRangeException("at");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            if(!this.IsValidUri(uri))
            {
                thrownew ArgumentException("uri");
            }
            ArtifactId artifact =this.GetArtifact(uri);
            this.m_id = Convert.ToInt32(artifact.ToolSpecificId, CultureInfo.InvariantCulture);
            this.m_tempId =this.m_id;
            this.LoadWorkItem(this.m_id, 0,new DateTime?(time));
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalWorkItem(WorkItemStore store, System.Uri uri, intrevision)
        {
            this.m_dirty =false;
            this.m_readonly =null;
            this.m_asof =null;
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem(WorkItemStore store, Uri uri, int revision)");
            if(store == null)
            {
                thrownew ArgumentNullException("store");
            }
            if(revision <= 0)
            {
                thrownew ArgumentOutOfRangeException("revision");
            }
            this.m_store = store;
            this.m_fieldsData =new WorkItemFieldData(this);
            this.m_linksData =new WorkItemLinkData(this);
            if(!this.IsValidUri(uri))
            {
                thrownew ArgumentException("uri");
            }
            ArtifactId artifact =this.GetArtifact(uri);
            this.m_id = Convert.ToInt32(artifact.ToolSpecificId, CultureInfo.InvariantCulture);
            this.m_tempId =this.m_id;
            this.LoadWorkItem(this.m_id, revision,null);
            this.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemNewEnd);
        }
 
        internalvoid ApplyFieldChange(intfieldId, objectvalue)
        {
            BrieCallBack bc =new BrieCallBack(this);
            WorkItemFieldData.FieldUpdate update =new WorkItemFieldData.FieldUpdate();
            update.Value = value;
            update.Flags = 0;
            bc.FieldUpdates.Add(fieldId, update);
            this.ApplyFieldChange(fieldId, bc, 2);
            bc.FieldUpdates.Remove(fieldId);
            this.FieldData.SetFieldValues(bc.FieldUpdates);
            this.Store.PsDatastore.BrieAccessCheck(bc, 1, fieldId);
            this.FieldData.SetFieldStates(bc.FieldStates);
        }
 
        privatevoid ApplyFieldChange(intfieldId, BrieCallBack bc, intrecursive)
        {
            if(fieldId != 0)
            {
                this.Store.PsDatastore.BrieInvalidateFields(bc, fieldId);
                bc.SetFieldUpdateFlags(WorkItemFieldData.FieldFlags.SetByDefaultRule);
                this.Store.PsDatastore.BrieAccessCheck(bc, 0x80, fieldId);
                bc.SetFieldUpdateFlags(0);
                this.Store.PsDatastore.BrieAccessCheck(bc, 0x40, fieldId);
            }
            Dictionary<int,bool=""> dictionary = bc.ResetChanges();
            if(recursive > 0)
            {
                foreach(int num in dictionary.Keys)
                {
                    this.ApplyFieldChange(num, bc, recursive - 1);
                }
            }
        }
 
        internalvoid ApplyRules()
        {
            this.ApplyRules(true);
        }
 
        internalvoid ApplyRules(boolfSetChangedBy)
        {
            this.FieldData.ResetChangedFields();
            BrieCallBack callback =new BrieCallBack(this);
            callback.SetFieldUpdateFlags(WorkItemFieldData.FieldFlags.SetByDefaultRule);
            this.Store.PsDatastore.BrieAccessCheck(callback, 0x80, 0);
            callback.SetFieldUpdateFlags(0);
            this.Store.PsDatastore.BrieAccessCheck(callback, 0x20, 0);
            this.ApplyFieldChange(0, callback, 2);
            this.FieldData.SetFieldValues(callback.FieldUpdates);
            this.Store.PsDatastore.BrieAccessCheck(callback, 1, 0);
            this.FieldData.SetAllFieldStates(callback.FieldStates);
            if(fSetChangedBy)
            {
                intid = 9;
                stringuserDisplayName = this.m_store.UserDisplayName;
                if(this.FieldData.SetUpdateFieldValue(id, userDisplayName, WorkItemFieldData.FieldFlags.SetByRule))
                {
                    this.ApplyFieldChange(id, userDisplayName);
                }
            }
            this.FieldData.FireEvents();
        }
 
        privateobject CalculateAuthorizedAsField(intrevision)
        {
            objectfieldValue = this.GetFieldValue(-6, revision);
            if(fieldValue isint)
            {
                returnthis.m_store.GetPersonNameById((int) fieldValue);
            }
            returnfieldValue;
        }
 
        internalvoid CalculateFieldLists(intfieldId)
        {
            BrieCallBack callback =new BrieCallBack(this);
            this.Store.PsDatastore.BrieAccessCheck(callback, 0x17, fieldId);
            this.FieldData.SetFieldStates(callback.FieldStates);
        }
 
        privateobject CalculateNodeNameField(intfname, int fid, int revision)
        {
            objectfieldValue = this.GetFieldValue(fid, revision);
            if(fieldValue isint)
            {
                returnthis.m_store.TreeIdToNodeName((int) fieldValue);
            }
            returnfieldValue;
        }
 
        privateobject CalculateTreeLevelField(intflevel, intflevel1, intfid, int revision)
        {
            objectfieldValue = this.GetFieldValue(fid, revision);
            if(fieldValue isint)
            {
                returnthis.m_store.TreeIdToNodeLevel((int) fieldValue, (flevel1 - flevel) + 1);
            }
            returnfieldValue;
        }
 
        privateobject CalculateTreePathField(intfpath, int fid, int revision)
        {
            objectfieldValue = this.GetFieldValue(fid, revision);
            if(fieldValue isint)
            {
                returnthis.m_store.TreeIdToPath((int) fieldValue);
            }
            returnfieldValue;
        }
 
        privatevoid CheckType()
        {
            WorkItemType type =this.Type;
        }
 
        privatevoid CheckUpdateCachedData()
        {
            boolflag = false;
            if(this.m_store.MetadataVersion !=this.m_metadataVersion)
            {
                flag =true;
            }
            intmetadataVersion = this.m_store.MetadataVersion;
            if(this.m_project ==null)
            {
                objectfieldValue = this.GetFieldValue(-2, -2);
                if(fieldValue != null)
                {
                    this.m_project =this.m_store.TreeIdToProject((int) fieldValue);
                }
            }
            elseif (flag)
            {
                this.m_project =this.m_store.Projects.GetById(this.m_project.Id);
                this.m_type =null;
            }
            if((this.m_type ==null) && (this.m_project !=null))
            {
                stringstr = (string)this.GetFieldValue(0x19, -2);
                if(!string.IsNullOrEmpty(str) &&this.m_project.WorkItemTypes.Contains(str))
                {
                    this.m_type =this.m_project.WorkItemTypes[str];
                }
            }
            this.m_metadataVersion = metadataVersion;
        }
 
        publicvoid Close()
        {
            if(!this.IsNew)
            {
                this.m_fieldsData =new WorkItemFieldData(this);
                this.m_linksData =new WorkItemLinkData(this);
                this.m_revisions =null;
                this.m_attachments =null;
                this.m_links =null;
                this.m_wlinks =null;
                this.m_wlinksHistory =null;
                this.m_fields =null;
                if(this.m_list !=null)
                {
                    this.m_openState = OpenState.Queried;
                }
                else
                {
                    this.m_openState = OpenState.Undefined;
                }
            }
        }
 
        internalvoid ConvertFieldValueToExternal(refobject value, System.Type type)
        {
            if((value == null) && (type ==typeof(string)))
            {
                value =string.Empty;
            }
            elseif (value isDateTime)
            {
                value =this.Store.ConvertToLocalTime((DateTime) value);
            }
        }
 
        internalWorkItemFieldData.FieldFlags ConvertFieldValueToInternal(refobject value, System.Type type)
        {
            if(value == null)
            {
                return0;
            }
            try
            {
                objectobj2 = value;
                if(value.GetType() != type)
                {
                    if((type == typeof(Guid)) && (valueis string))
                    {
                        obj2 =new Guid((string) value);
                    }
                    else
                    {
                        obj2 = Convert.ChangeType(value, type,this.Store.CultureInfo);
                    }
                }
                if(obj2 is string)
                {
                    obj2 = ((string) obj2).Trim();
                    if(string.IsNullOrEmpty((string) obj2))
                    {
                        obj2 =null;
                    }
                }
                elseif (obj2 isDateTime)
                {
                    DateTime time = (DateTime) obj2;
                    intyear = time.Year;
                    if((year < 0x6d9) || (year > 0x270f))
                    {
                        returnWorkItemFieldData.FieldFlags.InvalidDate;
                    }
                    obj2 =this.Store.ConvertToUniversalTime((DateTime) obj2);
                }
                value = obj2;
                return0;
            }
            catch(FormatException)
            {
                returnWorkItemFieldData.FieldFlags.InvalidType;
            }
            catch(OverflowException)
            {
                returnWorkItemFieldData.FieldFlags.InvalidType;
            }
            catch(InvalidCastException)
            {
                returnWorkItemFieldData.FieldFlags.InvalidType;
            }
        }
 
        publicWorkItem Copy()
        {
            returnthis.Copy(this.Type);
        }
 
        publicWorkItem Copy(WorkItemType targetType)
        {
            returnthis.Copy(targetType, WorkItemCopyFlags.CopyLinks);
        }
 
        publicWorkItem Copy(WorkItemType targetType, WorkItemCopyFlags flags)
        {
            if(targetType == null)
            {
                thrownew ArgumentNullException("targetType");
            }
            this.CheckType();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemCopyBegin);
            WorkItem target =new WorkItem(targetType);
            intid = targetType.Project.Id;
            foreach(FieldDefinition definition intargetType.FieldDefinitions)
            {
                if(!definition.IsCloneable)
                {
                    continue;
                }
                Field field =this.Fields.TryGetById(definition.Id);
                if((((field != null) && (field.Value !=null)) && !object.Equals(field.Value,string.Empty)) && (((definition.Id != -2) && (definition.Id != -104)) || ((field.Valueis int) && (this.m_store.TreeIdToProjectId((int) field.Value) == id))))
                {
                    target.FieldData.SetUpdateFieldValue(definition.Id, field.Value, 0);
                }
            }
            target.History = HistoryBuilder.BuildHistoryFromItem(this);
            if((flags & WorkItemCopyFlags.CopyFiles) != WorkItemCopyFlags.None)
            {
                foreach(Attachment attachment inthis.Attachments)
                {
                    target.Attachments.Add(newAttachment(attachment));
                }
            }
            if(((flags & WorkItemCopyFlags.CopyLinks) != WorkItemCopyFlags.None) &&this.Store.Equals(target.Store))
            {
                foreach(Link link inthis.Links)
                {
                    Link link2 = link.Clone(target);
                    if(link2 != null)
                    {
                        target.Links.Add(link2);
                    }
                }
                foreach(WorkItemLink link3 inthis.WorkItemLinks)
                {
                    Link link4 = link3.Clone(target);
                    if(link4 != null)
                    {
                        target.Links.Add(link4);
                    }
                }
            }
            if(!this.IsNew)
            {
                target.Links.Add(newRelatedLink(this.Id));
            }
            target.ApplyRules();
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemCopyEnd);
            returntarget;
        }
 
        privatevoid CreateLocalCopy(TfsWebClient client, WorkItemLinkData.AttachmentInfo fi)
        {
            stringtempFileName = GetTempFileName(this.m_store.CacheDirectory);
            UriBuilder builder =new UriBuilder(this.m_store.AttachmentServerUrl);
            builder.Query =string.Format(CultureInfo.InvariantCulture,"{0}={1}", new object[] {"FileID", fi.ExtId });
            client.DownloadFile(builder.Uri.AbsoluteUri.ToString(), tempFileName);
            File.SetCreationTimeUtc(tempFileName, fi.CreationDate);
            File.SetLastWriteTimeUtc(tempFileName, fi.LastWriteDate);
            fi.FileInfo =new FileInfo(tempFileName);
        }
 
        internalXmlElement CreateUpdateElement(XmlDocument xdoc, SaveFlags saveFlags,out List<xmlelement> xlist,out List<workitemlinkdata.workitemlinkinfo> links)
        {
            xlist =null;
            links =null;
            XmlElement xwi =null;
            xwi = xdoc.CreateElement(this.IsNew ?"InsertWorkItem" : "UpdateWorkItem");
            xwi.SetAttribute("ObjectType","WorkItem");
            if(this.IsNew)
            {
                xwi.SetAttribute("TempID", XmlConvert.ToString(-this.TemporaryId));
            }
            else
            {
                xwi.SetAttribute("WorkItemID", XmlConvert.ToString(this.Id));
                xwi.SetAttribute("Revision", XmlConvert.ToString(this.Rev));
            }
            XmlElement xc = xdoc.CreateElement("Columns");
            XmlElement xcc = xdoc.CreateElement("ComputedColumns");
            this.FieldData.AddUpdateElements(xdoc, xwi, xc, xcc);
            this.LinkData.AddUpdateElements(xdoc, xwi, saveFlags,out xlist, out links);
            if((xwi.ChildNodes.Count == 0) && (xc.ChildNodes.Count == 0))
            {
                returnnull;
            }
            xwi.AppendChild(xc);
            xwi.AppendChild(xcc);
            returnxwi;
        }
 
        internalvoid EnsureCollections()
        {
            if((this.m_openState != OpenState.Opened) && (this.m_openState != OpenState.New))
            {
                intrev = 0;
                if(!this.m_asof.HasValue && (this.m_list !=null))
                {
                    rev =this.m_list.GetAsOfRevision(this.m_index);
                }
                this.LoadWorkItem(this.m_id, rev,this.m_asof);
            }
        }
 
        privatestatic EditAction FieldIdToAction(intfid)
        {
            switch(fid)
            {
                case50:
                    returnEditAction.AddAttachment;
 
                case0x33:
                    returnEditAction.AddHyperLink;
 
                case0x3a:
                    returnEditAction.AddExternalLink;
 
                case0x25:
                    returnEditAction.AddWorkItemLink;
            }
            thrownew UnexpectedErrorException();
        }
 
        privatevoid FinishConstruction(refEditActionSet set)
        {
            if((set.Flags & EditActionFlags.FieldChanges) != 0)
            {
                EditActionInfo info =set.Actions.Array[set.Actions.Offset];
                set.Tag = HistoryBuilder.BuildTagLine(this, info.Index);
                set.Description = (string)this.GetFieldValue(0x36, info.Index);
            }
            else
            {
                set.Tag = HistoryBuilder.BuildTagLineLinks(this,this.m_store.GetPersonNameById(set.ChangedBy));
                set.Description =string.Empty;
            }
        }
 
        internalvoid FireCollectionChangeEvent(objectupdatedCollection, objectupdatedItem, LinkAction action)
        {
            if(!this.m_IsUpdating && (this.m_fieldEventHandler !=null))
            {
                this.m_fieldEventHandler(this,new WorkItemLinkEventArgs(updatedCollection, updatedItem, action));
            }
        }
 
        internalvoid FireFieldChangeEvent(intid)
        {
            if((!this.m_IsUpdating &&this.IsValidType) && (this.m_fieldEventHandler !=null))
            {
                Field o =this.Fields.TryGetById(id);
                if(o != null)
                {
                    this.m_fieldEventHandler(this,new WorkItemEventArgs(o));
                }
            }
        }
 
        internalvoid FireWorkItemChangeEvent()
        {
            if(!this.m_IsUpdating && (this.m_fieldEventHandler !=null))
            {
                this.m_fieldEventHandler(this,new WorkItemEventArgs(null));
            }
        }
 
        internalbool GetAccessDenied()
        {
            return(this.m_openState == OpenState.AccessDenied);
        }
 
        internalobject GetActionObject(EditActionInfo a)
        {
            if(a.Action == EditAction.None)
            {
                returnnull;
            }
            if(a.Action == EditAction.Revision)
            {
                returnthis.Revisions[a.Index];
            }
            returnthis.LinkData.GetLinkInfo(a.Index);
        }
 
        internalEditActionSet[] GetActionsHistory()
        {
            intrevisionCount = this.FieldData.GetRevisionCount();
            intlinkInfoCount = this.LinkData.GetLinkInfoCount();
            EditActionInfo[] array =new EditActionInfo[revisionCount + (linkInfoCount * 2)];
            intlength = 0;
            for(int i = 0; i < revisionCount; i++)
            {
                EditActionInfo info =new EditActionInfo();
                info.Action = EditAction.Revision;
                info.ChangedDate = (DateTime)this.FieldData.GetFieldValue(-4, i);
                info.ChangedBy = (int)this.FieldData.GetFieldValue(-6, i);
                info.Index = i;
                array[length++] = info;
            }
            for(int j = 0; j < linkInfoCount; j++)
            {
                WorkItemLinkData.LinkInfo linkInfo =this.LinkData.GetLinkInfo(j);
                if(linkInfo != null)
                {
                    WorkItemLinkData.WorkItemLinkInfo info3 = linkInfoas WorkItemLinkData.WorkItemLinkInfo;
                    if(linkInfo.AddedDate != WorkItemStore.FutureDateTimeValue)
                    {
                        EditActionInfo info4 =new EditActionInfo();
                        info4.ChangedDate = linkInfo.AddedDate;
                        info4.Index = j;
                        info4.ChangedBy = (info3 !=null) ? info3.AddedBy : 0;
                        info4.Action = FieldIdToAction(linkInfo.FieldId);
                        array[length++] = info4;
                    }
                    if(linkInfo.RemovedDate != WorkItemStore.FutureDateTimeValue)
                    {
                        EditActionInfo info5 =new EditActionInfo();
                        info5.ChangedDate = linkInfo.RemovedDate;
                        info5.Index = j;
                        info5.ChangedBy = (info3 !=null) ? info3.RemovedBy : 0;
                        info5.Action = FieldIdToAction(linkInfo.FieldId) + 1;
                        array[length++] = info5;
                    }
                }
            }
            Array.Sort<editactioninfo>(array, 0, length,new EditActionInfoComparator(this));
            EditActionSetset = new EditActionSet();
            intoffset = -1;
            List<editactionset> list =new List<editactionset>();
            for(int k = 0; k < length; k++)
            {
                EditActionInfo info6 = array[k];
                if((info6.ChangedDate != set.ChangedDate) || ((info6.ChangedBy != 0) && (info6.ChangedBy !=set.ChangedBy)))
                {
                    if(offset >= 0)
                    {
                        set.Actions =new ArraySegment<editactioninfo>(array, offset, k - offset);
                        this.FinishConstruction(refset);
                        list.Add(set);
                    }
                    set= new EditActionSet();
                    set.ChangedDate = info6.ChangedDate;
                    set.ChangedBy = info6.ChangedBy;
                    offset = k;
                }
                set.Flags |= ((int) 1) << (info6.Action / 2);
            }
            if(offset >= 0)
            {
                set.Actions =new ArraySegment<editactioninfo>(array, offset, length - offset);
                this.FinishConstruction(refset);
                list.Add(set);
            }
            returnlist.ToArray();
        }
 
        privateArtifactId GetArtifact(System.Uri uri)
        {
            TeamFoundationTrace.Verbose("Entering WorkItem.GetArtifact, id = {0}, uri = {1}",new object[] {this.Id, uri });
            returnLinkingUtilities.DecodeUri(uri.ToString());
        }
 
        internalbool GetCalculatedFieldValue(intid, int revision, out object value)
        {
            switch(id)
            {
                case-12:
                    value =this.CalculateNodeNameField(id, -2, revision);
                    returntrue;
 
                case-7:
                    value =this.CalculateTreePathField(id, -2, revision);
                    returntrue;
 
                case-1:
                    value =this.CalculateAuthorizedAsField(revision);
                    returntrue;
 
                case-56:
                case-55:
                case-54:
                case-53:
                case-52:
                case-51:
                case-50:
                    value =this.CalculateTreeLevelField(id, -50, -104, revision);
                    returntrue;
 
                case-49:
                case-48:
                case-47:
                case-46:
                case-45:
                case-44:
                case-43:
                    value =this.CalculateTreeLevelField(id, -43, -2, revision);
                    returntrue;
 
                case-42:
                    value = (this.Project !=null) ? this.Project.Name :string.Empty;
                    returntrue;
 
                case-105:
                    value =this.CalculateTreePathField(id, -104, revision);
                    returntrue;
            }
            if(this.IsOpen)
            {
                switch(id)
                {
                    case-32:
                        value =this.LinkData.ComputeLinkCount(0x33, revision);
                        returntrue;
 
                    case-31:
                        value =this.LinkData.ComputeLinkCount(50, revision);
                        returntrue;
 
                    case0x4b:
                        value =this.LinkData.ComputeLinkCount(0x25, revision);
                        returntrue;
 
                    case-57:
                        value =this.LinkData.ComputeLinkCount(0x3a, revision);
                        returntrue;
                }
            }
            value =null;
            returnfalse;
        }
 
        internalobject GetFieldValue(intid, int revision)
        {
            if(id == -3)
            {
                returnthis.m_id;
            }
            returnthis.m_fieldsData.GetFieldValue(id, revision);
        }
 
        internalobject GetFieldValueExternal(FieldDefinition fd,int revision)
        {
            objectfieldValue = this.GetFieldValue(fd.Id, revision);
            if(fieldValue isServerDefaultFieldValue)
            {
                fieldValue =this.GetFieldValue(fd.Id, revision - 1);
            }
            this.ConvertFieldValueToExternal(reffieldValue, fd.SystemType);
            returnfieldValue;
        }
 
        publicstring GetNextState(stringaction)
        {
            returnthis.Type.GetNextState(this.State, action);
        }
 
        privatestatic stringGetTempFileName(stringpath)
        {
            returnPath.Combine(path, Guid.NewGuid().ToString());
        }
 
        internalvoid HandleLinkCollectionChange(WorkItemLinkData.LinkInfo li, LinkAction action)
        {
            this.FieldData.ResetChangedFields();
            switch(li.FieldId)
            {
                case50:
                    if((action == LinkAction.Added) || (action == LinkAction.Removed))
                    {
                        this.ApplyFieldChange(-31,this.LinkData.ComputeLinkCount(50, -2));
                        this.FireFieldChangeEvent(-31);
                    }
                    this.Attachments.HandleChange(li, action);
                    break;
 
                case0x33:
                    if((action == LinkAction.Added) || (action == LinkAction.Removed))
                    {
                        this.ApplyFieldChange(-32,this.LinkData.ComputeLinkCount(0x33, -2));
                        this.FireFieldChangeEvent(-32);
                    }
                    this.Links.HandleChange(li, action);
                    break;
 
                case0x3a:
                    if((action == LinkAction.Added) || (action == LinkAction.Removed))
                    {
                        this.ApplyFieldChange(-57,this.LinkData.ComputeLinkCount(0x3a, -2));
                        this.FireFieldChangeEvent(-57);
                    }
                    this.Links.HandleChange(li, action);
                    break;
 
                case0x25:
                    if((action == LinkAction.Added) || (action == LinkAction.Removed))
                    {
                        this.ApplyFieldChange(0x4b,this.LinkData.ComputeLinkCount(0x25, -2));
                        this.FireFieldChangeEvent(0x4b);
                    }
                    this.Links.HandleChange(li, action);
                    this.WorkItemLinks.HandleChange(li, action);
                    break;
            }
            this.FieldData.FireEvents();
        }
 
        privatevoid InitNew(WorkItemType type)
        {
            intid = type.Project.Id;
            this.FieldData.SetUpdateFieldValue(-2, id, 0);
            this.FieldData.SetUpdateFieldValue(-104, id, 0);
            this.FieldData.SetUpdateFieldValue(0x19, type.Name, 0);
            this.m_type = type;
            this.m_project = type.Project;
        }
 
        internalbool? IsChangedInRevision(intid, int revision)
        {
            switch(id)
            {
                case-7:
                case-49:
                case-48:
                case-47:
                case-46:
                case-45:
                case-44:
                case-43:
                case-42:
                case-12:
                    id = -2;
                    break;
 
                case-1:
                    id = -6;
                    break;
 
                case0x4b:
                case-57:
                case-32:
                case-31:
                    returnnull;
 
                case-56:
                case-55:
                case-54:
                case-53:
                case-52:
                case-51:
                case-50:
                case-105:
                    id = -104;
                    break;
            }
            returnthis.m_fieldsData.IsChangedInRevision(id, revision);
        }
 
        internalbool IsFieldValueValid(intid)
        {
            return((this.FieldData.GetFieldState(id).Flags & WorkItemFieldData.FieldFlags.InvalidMask) == 0);
        }
 
        publicbool IsValid()
        {
            returnthis.FieldData.IsValid();
        }
 
        privatebool IsValidUri(System.Uri uri)
        {
            TeamFoundationTrace.Verbose("Entering WorkItem.IsValidUri, id = {0}, uri = {1}",new object[] {this.Id, uri });
            if(uri != null)
            {
                try
                {
                    ArtifactId artifact =this.GetArtifact(uri);
                    if((TFStringComparer.ArtifactType.Equals(artifact.ArtifactType,"WorkItem") && TFStringComparer.ArtifactTool.Equals(artifact.Tool,"WorkItemTracking")) && (Convert.ToInt32(artifact.ToolSpecificId, CultureInfo.InvariantCulture) > 0))
                    {
                        returntrue;
                    }
                    TeamFoundationTrace.Verbose("Invalid Work Item URI: {0}",new object[] { uri.ToString() });
                    TeamFoundationTrace.Verbose("        This: {0}, {1}, {2}",new object[] { artifact.ArtifactType, artifact.Tool, artifact.ToolSpecificId });
                    TeamFoundationTrace.Verbose("   Should be: {0}, {1}, #>0",new object[] {"WorkItem", "WorkItemTracking" });
                }
                catch
                {
                    TeamFoundationTrace.Error("Exception while parsing URI: {0}",new object[] { uri.ToString() });
                }
            }
            returnfalse;
        }
 
        privatevoid LoadWorkItem(intid, int rev, DateTime? asof)
        {
            IWorkItemRowSets sets;
            this.m_store.LoadWorkItem(id, rev, asof,out sets);
            this.m_asof = asof;
            if(!this.FieldData.LoadData(sets))
            {
                thrownew DeniedOrNotExistException(ResourceStrings.ErrorWorkItemNotExistOrNoAccess);
            }
            this.LinkData.LoadData(sets);
            if(rev != 0)
            {
                this.m_asof =new DateTime?((DateTime)this.GetFieldValue(-4, -3));
            }
            this.m_openState = OpenState.Opened;
            this.m_readonly =null;
            this.m_dataVersion++;
        }
 
        objectIRevisionInternal.GetCurrentFieldValue(FieldDefinition fd)
        {
            returnthis.GetFieldValueExternal(fd, -2);
        }
 
        objectIRevisionInternal.GetOriginalFieldValue(FieldDefinition fd)
        {
            returnthis.GetFieldValueExternal(fd, -3);
        }
 
        voidIRevisionInternal.SetFieldValue(FieldDefinition fd, object value)
        {
            this.SetFieldValueExternal(fd, value);
        }
 
        publicvoid Open()
        {
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemOpenBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem.Open, id = {0}",new object[] {this.Id });
            if(!this.IsNew && !this.IsOpen)
            {
                this.LoadWorkItem(this.m_id, 0, null);
                this.ApplyRules();
                this.RefreshCachedData();
                this.FireWorkItemChangeEvent();
            }
            TeamFoundationTrace.Verbose("Exiting WorkItem.Open, id = {0}",new object[] {this.Id });
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemOpenEnd);
        }
 
        publicvoid PartialOpen()
        {
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemPartialOpenBegin);
            TeamFoundationTrace.Verbose("Entering WorkItem.PartialOpen, id = {0}",new object[] {this.Id });
            if((!this.IsNew && !this.IsOpen) && !this.IsPartialOpen)
            {
                if(this.m_list ==null)
                {
                    thrownew ValidationException(ResourceStrings.ErrorWorkItemNeedCollection);
                }
                if(!this.m_list.QueryFieldValues(this.m_index,null))
                {
                    thrownew DeniedOrNotExistException();
                }
                this.m_openState = OpenState.PartiallyOpened;
                this.ApplyRules();
                this.RefreshCachedData();
                this.FireWorkItemChangeEvent();
                this.CheckType();
            }
            TeamFoundationTrace.Verbose("Exiting WorkItem.Open, id = {0}",new object[] {this.Id });
            Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemPartialOpenEnd);
        }
 
        internalvoid PostSave()
        {
            this.LinkData.ProcessResultQueue();
            this.RefreshCachedData();
            this.FieldData.Reset();
            this.ApplyRules(false);
            this.m_IsUpdating =false;
            this.FireWorkItemChangeEvent();
        }
 
        internalvoid PostSaveError()
        {
            this.m_IsUpdating =false;
        }
 
        internalvoid PreSave()
        {
            this.m_IsUpdating =true;
            this.LinkData.Check();
            this.LinkData.ResetResultQueue();
            this.UploadAttachments();
        }
 
        internalvoid ProcessFieldChange(intid)
        {
            if(this.m_fields !=null)
            {
                this.m_fields.DropCachedData();
            }
            if(this.IsValidType)
            {
                intnum = id;
                switch(num)
                {
                    case-105:
                        this.ProcessTreePathField(-105, -104, Microsoft.TeamFoundation.WorkItemTracking.Client.DataStore.PsCSSType.CSSTypeIteration);
                        break;
 
                    case-104:
                        this.ProcessTreeIdField(-104, -105, s_iterationDependentFieldIds);
                        break;
 
                    case-7:
                        this.ProcessTreePathField(-7, -2, Microsoft.TeamFoundation.WorkItemTracking.Client.DataStore.PsCSSType.CSSTypeArea);
                        break;
 
                    default:
                        if(num == -2)
                        {
                            this.ProcessTreeIdField(-2, -7, s_areaDependentFieldIds);
                        }
                        break;
                }
                this.FieldData.RegisterChangedField(id);
            }
        }
 
        privatevoid ProcessTreeIdField(intfid, int fpath, int[] affected)
        {
            if(this.IsFieldValueValid(fid))
            {
                objectfieldValue = this.GetFieldValue(fid, -2);
                if((fieldValue == null) || (fieldValueis int))
                {
                    if(!this.FieldData.ResetUpdateFieldValue(fpath))
                    {
                        this.FieldData.RegisterChangedField(fpath);
                    }
                    if(affected != null)
                    {
                        for(int i = 0; i < affected.Length; i++)
                        {
                            this.FieldData.RegisterChangedField(affected[i]);
                        }
                    }
                }
            }
        }
 
        privatevoid ProcessTreePathField(intfpath, int fid, Microsoft.TeamFoundation.WorkItemTracking.Client.DataStore.PsCSSType csstype)
        {
            if(this.IsFieldValueValid(fpath))
            {
                objectfieldValue = this.GetFieldValue(fpath, -2);
                if(fieldValue == null)
                {
                    this.FieldData.SetUpdateFieldValue(fpath, fieldValue, WorkItemFieldData.FieldFlags.InvalidPath);
                }
                elseif (fieldValue is string)
                {
                    intnum = this.m_store.TreeIdFromPath(this.Project.Id, (string) fieldValue, csstype);
                    if(num != 0)
                    {
                        this.SetFieldValue(fid, num, 0);
                        this.FieldData.ResetUpdateFieldValue(fpath);
                    }
                    else
                    {
                        this.FieldData.SetUpdateFieldValue(fpath, fieldValue, WorkItemFieldData.FieldFlags.InvalidPath);
                    }
                }
            }
        }
 
        internalbool QueryFieldValue(intfield)
        {
            if(this.m_list ==null)
            {
                returnfalse;
            }
            if(this.IsAccessDenied || !this.m_list.QueryFieldValues(this.m_index,new int[] { field }))
            {
                thrownew DeniedOrNotExistException();
            }
            returntrue;
        }
 
        privatevoid RefreshCachedData()
        {
            if(this.IsValidType)
            {
                if(this.m_revisions !=null)
                {
                    this.m_revisions.Refresh();
                }
                if(this.m_attachments !=null)
                {
                    this.m_attachments.Refresh();
                }
                if(this.m_links !=null)
                {
                    this.m_links.Refresh();
                }
                if(this.m_wlinks !=null)
                {
                    this.m_wlinks.Refresh();
                }
                if(this.m_wlinksHistory !=null)
                {
                    this.m_wlinksHistory.Refresh();
                }
                if(this.m_fields !=null)
                {
                    this.m_fields.DropCachedData();
                }
            }
            this.m_dirty =null;
        }
 
        publicvoid Reset()
        {
            TeamFoundationTrace.Verbose("Entering WorkItem.Reset, id = {0}",new object[] {this.Id });
            this.FieldData.Reset();
            this.LinkData.Reset();
            if(this.IsNew)
            {
                this.InitNew(this.Type);
            }
            this.ApplyRules();
            this.RefreshCachedData();
            this.FireWorkItemChangeEvent();
            this.CheckType();
        }
 
        internalvoid ResetDirty()
        {
            this.m_dirty =null;
        }
 
        publicvoid Save()
        {
            this.Save(SaveFlags.None);
        }
 
        publicvoid Save(SaveFlags saveFlags)
        {
            if(this.IsDirty)
            {
                if(!this.IsValid())
                {
                    thrownew ValidationException(ResourceStrings.ErrorWorkItemIsNotReadyToSave);
                }
                Node node =null;
                objectfieldValue = this.GetFieldValue(-2, -2);
                if(fieldValue isint)
                {
                    node =this.m_store.TreeIdToNode((int) fieldValue);
                }
                if(node == null)
                {
                    thrownew ValidationException(ResourceStrings.ErrorWorkItemIsNotReadyToSave);
                }
                if(!node.HasWorkItemWriteRights)
                {
                    thrownew ValidationException(ResourceStrings.ErrorNoAreaWriteAccess);
                }
                Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemSaveBegin);
                TeamFoundationTrace.Verbose("Entering WorkItem.Save, id = {0}",new object[] {this.Id });
                try
                {
                    this.Store.SaveWorkItems(newWorkItem[] { this}, false, saveFlags);
                }
                catch(WorkItemLinkValidationException exception)
                {
                    throwOME.TranslateLinkingValidationException(exception, this.m_store, this);
                }
                finally
                {
                    Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMWorkItemSaveEnd);
                }
            }
        }
 
        internalvoid SetAccessDenied()
        {
            this.m_openState = OpenState.AccessDenied;
        }
 
        internalvoid SetFieldValue(intid, object value, WorkItemFieldData.FieldFlags flags)
        {
            if(id == -3)
            {
                thrownew ValidationException(ResourceStrings.ErrorCantModifyIdField);
            }
            boolflag = (flags & (WorkItemFieldData.FieldFlags.SetByDefaultRule | WorkItemFieldData.FieldFlags.SetByRule)) == 0;
            if(this.FieldData.SetUpdateFieldValue(id, value, flags) && flag)
            {
                this.ApplyFieldChange(id, value);
            }
        }
 
        internalvoid SetFieldValueExternal(FieldDefinition fd,object value)
        {
            this.CheckType();
            WorkItemFieldData.FieldFlags flags =this.ConvertFieldValueToInternal(refvalue, fd.SystemType);
            if(fd.Id == -2)
            {
                if(!(value isint) || !this.m_store.VerifyTreeId(this.Project.Id, (int) value, Microsoft.TeamFoundation.WorkItemTracking.Client.DataStore.PsCSSType.CSSTypeArea))
                {
                    thrownew InvalidTreeNodeException();
                }
            }
            elseif ((fd.Id == -104) && (!(valueis int) || !this.m_store.VerifyTreeId(this.Project.Id, (int) value, Microsoft.TeamFoundation.WorkItemTracking.Client.DataStore.PsCSSType.CSSTypeIteration)))
            {
                thrownew InvalidTreeNodeException();
            }
            objectfieldValue = this.GetFieldValue(fd.Id, -2);
            if((fd.Id == 9) || !object.Equals(value, fieldValue))
            {
                if(!fd.IsEditable)
                {
                    thrownew ValidationException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorReadOnlyField,new object[] { fd.Name }));
                }
                if(fieldValue isServerDefaultFieldValue)
                {
                    if((value != null) && (!(valueis string) || (((string) value).Length != 0)))
                    {
                        thrownew ValidationException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorReadOnlyField,new object[] { fd.Name }));
                    }
                }
                else
                {
                    if((fd.SystemType == typeof(string)) && (valueis string))
                    {
                        strings = (string) value;
                        if((fd.FieldType == FieldType.String) && (s.Length >= 0x100))
                        {
                            flags |= WorkItemFieldData.FieldFlags.InvalidTooLong;
                        }
                        if(!OMStringUtil.IsValidFieldValueString(s, fd.IsLongText))
                        {
                            flags |= WorkItemFieldData.FieldFlags.InvalidSpecialChars;
                        }
                    }
                    this.FieldData.ResetChangedFields();
                    this.SetFieldValue(fd.Id, value, flags);
                    this.FieldData.FireEvents();
                }
            }
        }
 
        internalvoid SetListIndex(WorkItemCollection list,int index)
        {
            this.m_list = list;
            this.m_index = index;
        }
 
        publicvoid SyncToLatest()
        {
            TeamFoundationTrace.Verbose("Entering WorkItem.SyncToLatest, id = {0}",new object[] {this.Id });
            if(!this.IsNew)
            {
                this.FieldData.Reset();
                this.LinkData.Reset();
                this.LoadWorkItem(this.m_id, 0, null);
                this.ApplyRules();
                this.RefreshCachedData();
                this.FireWorkItemChangeEvent();
            }
        }
 
        internalvoid TakeUpdateLinkResult(WorkItemLinkData.WorkItemLinkInfo li, XmlElement result)
        {
            this.LinkData.TakeUpdateLinkResult(li, result);
            this.m_dataVersion++;
        }
 
        internalvoid TakeUpdateResult(XmlElement result)
        {
            intnum = XmlConvert.ToInt32(result.GetAttribute("ID"));
            intnewRev = XmlConvert.ToInt32(result.GetAttribute("Revision"));
            if((this.IsNew ? (num == 0) : (num !=this.m_id)) || (newRev == 0))
            {
                thrownew UnexpectedErrorException(ResourceStrings.UnrecognizedServerData);
            }
            if(this.m_id == 0)
            {
                this.m_id = num;
                this.m_tempId =this.m_id;
            }
            this.FieldData.TakeUpdateResult(result, newRev);
            this.LinkData.TakeUpdateResult(result);
            this.m_asof =null;
            if(this.m_openState == OpenState.New)
            {
                this.m_openState = OpenState.Opened;
            }
            this.m_readonly =null;
            this.m_dataVersion++;
        }
 
        privatevoid UploadAttachments()
        {
            if(this.LinkData.GetAddedLinksCount() != 0)
            {
                stringstr = this.Project.Uri.ToString();
                stringstr2 = string.Empty;
                if(this.Project.Id ==this.AreaId)
                {
                    str2 =this.Project.AreaRootNodeUri.ToString();
                }
                else
                {
                    foreach(Node node inthis.Project.AreaRootNodes)
                    {
                        if(node.Id == this.AreaId)
                        {
                            str2 = node.Uri.ToString();
                            break;
                        }
                        try
                        {
                            str2 = node.FindNodeInSubTree(this.AreaId).Uri.ToString();
                            break;
                        }
                        catch(DeniedOrNotExistException)
                        {
                            continue;
                        }
                    }
                }
                Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMAttachmentUploadBegin);
                WorkItemServer clientService =this.Store.ClientService;
                TfsWebClient client =null;
                foreach(WorkItemLinkData.AttachmentInfo info inthis.LinkData.GetAddedLinks(50))
                {
                    if(info.IsUploaded)
                    {
                        continue;
                    }
                    if(info.FileInfo == null)
                    {
                        if(!info.IsLocalCopy)
                        {
                            continue;
                        }
                        if(client == null)
                        {
                            client =new TfsWebClient(this.m_store.TeamProjectCollection);
                        }
                        this.CreateLocalCopy(client, info);
                    }
                    try
                    {
                        info.FileInfo.Refresh();
                        if(!info.FileInfo.Exists || (info.LastWriteDate.Ticks != info.FileInfo.LastWriteTimeUtc.Ticks))
                        {
                            thrownew FileAttachmentException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.AttachmentChangedException,new object[] { info.FileInfo.FullName }),new Attachment(this, info));
                        }
                        if(info.FileInfo.Length > clientService.MaxAttachmentSize)
                        {
                            clientService.UpdateMaxAttachmentSize();
                            if(info.FileInfo.Length > clientService.MaxAttachmentSize)
                            {
                                thrownew FileAttachmentException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.FileUploadedExceededMax,new object[] { info.Attribute, clientService.MaxAttachmentSize }),new Attachment(this, info));
                            }
                        }
                        using(Stream stream = info.FileInfo.OpenRead())
                        {
                            FileAttachment fileAttachment =new FileAttachment();
                            fileAttachment.FileNameGUID =new Guid(info.Path);
                            fileAttachment.AreaNodeUri = str2;
                            fileAttachment.ProjectUri = str;
                            fileAttachment.LocalFile = stream;
                            clientService.UploadFile(fileAttachment);
                        }
                        info.IsUploaded =true;
                    }
                    catch(FileAttachmentException)
                    {
                        throw;
                    }
                    catch(FileNotFoundException exception)
                    {
                        thrownew FileAttachmentException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.AttachmentNotFoundException,new object[] { info.FileInfo.FullName }),new Attachment(this, info), exception);
                    }
                    catch(Exception exception2)
                    {
                        thrownew FileAttachmentException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorAttachmentUploadFailed,new object[] { exception2.Message }), exception2);
                    }
                    finally
                    {
                        if(info.IsLocalCopy && (info.FileInfo != null))
                        {
                            info.FileInfo.Delete();
                            info.FileInfo =null;
                        }
                        if(client != null)
                        {
                            client.Dispose();
                        }
                    }
                    info.IsLocalCopy =false;
                }
                Microsoft.TeamFoundation.Common.Marker.Process(Microsoft.TeamFoundation.Common.Mark.OMAttachmentUploadEnd);
            }
        }
 
        publicArrayList Validate()
        {
            returnthis.FieldData.Validate();
        }
 
        publicint AreaId
        {
            get
            {
                objectobj2 = this[CoreField.AreaId];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
            set
            {
                this[CoreField.AreaId] = value;
            }
        }
 
        publicstring AreaPath
        {
            get
            {
                return(string)this[CoreField.AreaPath];
            }
            set
            {
                this[CoreField.AreaPath] = value;
            }
        }
 
        internalDateTime? AsOfUTC
        {
            get
            {
                returnthis.m_asof;
            }
        }
 
        publicint AttachedFileCount
        {
            get
            {
                objectobj2 = this[CoreField.AttachedFileCount];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
        }
 
        publicAttachmentCollection Attachments
        {
            get
            {
                if(this.m_attachments ==null)
                {
                    this.m_attachments =new AttachmentCollection(this, -2);
                }
                returnthis.m_attachments;
            }
        }
 
        publicstring ChangedBy
        {
            get
            {
                return(string)this[CoreField.ChangedBy];
            }
        }
 
        publicDateTime ChangedDate
        {
            get
            {
                objectobj2 = this[CoreField.ChangedDate];
                if(obj2 != null)
                {
                    return(DateTime) obj2;
                }
                returnDateTime.MinValue;
            }
        }
 
        publicstring CreatedBy
        {
            get
            {
                return(string)this[CoreField.CreatedBy];
            }
        }
 
        publicDateTime CreatedDate
        {
            get
            {
                objectobj2 = this[CoreField.CreatedDate];
                if(obj2 != null)
                {
                    return(DateTime) obj2;
                }
                returnDateTime.MinValue;
            }
        }
 
        publicstring Description
        {
            get
            {
                return(string)this[CoreField.Description];
            }
            set
            {
                this[CoreField.Description] = value;
            }
        }
 
        publicstring DisplayForm
        {
            get
            {
                returnthis.Type.DisplayForm;
            }
        }
 
        publicint ExternalLinkCount
        {
            get
            {
                objectobj2 = this[CoreField.ExternalLinkCount];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
        }
 
        internalWorkItemFieldData FieldData
        {
            get
            {
                returnthis.m_fieldsData;
            }
        }
 
        publicFieldCollection Fields
        {
            get
            {
                if(this.m_fields ==null)
                {
                    this.m_fields =new FieldCollection(this,this.Type.FieldDefinitions);
                }
                returnthis.m_fields;
            }
        }
 
        publicstring History
        {
            get
            {
                return(string)this[CoreField.History];
            }
            set
            {
                this[CoreField.History] = value;
            }
        }
 
        publicint HyperLinkCount
        {
            get
            {
                objectobj2 = this[CoreField.HyperLinkCount];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
        }
 
        publicint Id
        {
            get
            {
                returnthis.m_id;
            }
        }
 
        internalint InternalVersion
        {
            get
            {
                returnthis.m_dataVersion;
            }
        }
 
        internalbool IsAccessDenied
        {
            get
            {
                if((this.m_openState == OpenState.Queried) && (this.m_list !=null))
                {
                    this.m_list.QueryFieldValues(this.m_index,new int[] { -2 });
                }
                return(this.m_openState == OpenState.AccessDenied);
            }
        }
 
        publicbool IsDirty
        {
            get
            {
                if(!this.m_dirty.HasValue)
                {
                    this.m_dirty =false;
                    bool? dirty =this.m_dirty;
                    this.m_dirty =this.FieldData.IsDirty() ? ((bool?)true) : dirty;
                    bool? nullable2 =this.m_dirty;
                    this.m_dirty =this.LinkData.IsDirty() ? ((bool?)true) : nullable2;
                }
                returnthis.m_dirty.Value;
            }
        }
 
        publicbool IsNew
        {
            get
            {
                return(this.m_id == 0);
            }
        }
 
        publicbool IsOpen
        {
            get
            {
                if(this.m_openState != OpenState.New)
                {
                    return(this.m_openState == OpenState.Opened);
                }
                returntrue;
            }
        }
 
        publicbool IsPartialOpen
        {
            get
            {
                return(this.m_openState == OpenState.PartiallyOpened);
            }
        }
 
        publicbool IsReadOnly
        {
            get
            {
                if(!this.m_readonly.HasValue)
                {
                    objectfieldValue = this.GetFieldValue(-2, -3);
                    if(fieldValue isint)
                    {
                        Node node =this.m_store.TreeIdToNode((int) fieldValue);
                        if(node != null)
                        {
                            this.m_readonly =new bool?(!node.HasWorkItemWriteRights);
                        }
                    }
                }
                if(this.m_readonly.HasValue && !this.m_readonly.Value)
                {
                    return!this.IsValidType;
                }
                returntrue;
            }
        }
 
        publicbool IsReadOnlyOpen
        {
            get
            {
                if(!this.IsOpen && !this.IsPartialOpen)
                {
                    returnfalse;
                }
                returnthis.IsReadOnly;
            }
        }
 
        internalbool IsRevised
        {
            get
            {
                DateTime revisedDate =this.RevisedDate;
                return((revisedDate != DateTime.MinValue) && (revisedDate < WorkItemStore.FutureDateTimeValue));
            }
        }
 
        privatebool IsValidType
        {
            get
            {
                this.CheckUpdateCachedData();
                return(this.m_type !=null);
            }
        }
 
        publicobject this[stringname]
        {
            get
            {
                if(name == null)
                {
                    thrownew ArgumentNullException("name");
                }
                returnthis.Fields[name].Value;
            }
            set
            {
                if(name == null)
                {
                    thrownew ArgumentNullException("name");
                }
                this.Fields[name].Value = value;
            }
        }
 
        publicobject this[CoreField id]
        {
            get
            {
                returnthis.Fields[id].Value;
            }
            set
            {
                this.Fields[id].Value = value;
            }
        }
 
        publicint IterationId
        {
            get
            {
                objectobj2 = this[CoreField.IterationId];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
            set
            {
                this[CoreField.IterationId] = value;
            }
        }
 
        publicstring IterationPath
        {
            get
            {
                return(string)this[CoreField.IterationPath];
            }
            set
            {
                this[CoreField.IterationPath] = value;
            }
        }
 
        internalWorkItemLinkData LinkData
        {
            get
            {
                returnthis.m_linksData;
            }
        }
 
        publicLinkCollection Links
        {
            get
            {
                if(this.m_links ==null)
                {
                    this.m_links =new LinkCollection(this, -2);
                }
                returnthis.m_links;
            }
        }
 
        boolIRevisionInternal.IsReadOnly
        {
            get
            {
                returnfalse;
            }
        }
 
        intIRevisionInternal.Number
        {
            get
            {
                return-2;
            }
        }
 
        WorkItem IRevisionInternal.WorkItem
        {
            get
            {
                returnthis;
            }
        }
 
        publicstring NodeName
        {
            get
            {
                return(string)this[CoreField.NodeName];
            }
        }
 
        publicMicrosoft.TeamFoundation.WorkItemTracking.Client.Project Project
        {
            get
            {
                this.CheckUpdateCachedData();
                if(this.m_project ==null)
                {
                    thrownew DeniedOrNotExistException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorProjectNotExist,new object[] {string.Empty }));
                }
                returnthis.m_project;
            }
        }
 
        publicstring Reason
        {
            get
            {
                return(string)this[CoreField.Reason];
            }
            set
            {
                this[CoreField.Reason] = value;
            }
        }
 
        publicint RelatedLinkCount
        {
            get
            {
                objectobj2 = this[CoreField.RelatedLinkCount];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
        }
 
        publicint Rev
        {
            get
            {
                returnthis.Revision;
            }
        }
 
        publicDateTime RevisedDate
        {
            get
            {
                objectobj2 = this[CoreField.RevisedDate];
                if(obj2 != null)
                {
                    return(DateTime) obj2;
                }
                returnDateTime.MinValue;
            }
        }
 
        publicint Revision
        {
            get
            {
                objectobj2 = this[CoreField.Rev];
                if(obj2 != null)
                {
                    return(int) obj2;
                }
                return0;
            }
        }
 
        publicRevisionCollection Revisions
        {
            get
            {
                if(this.m_revisions ==null)
                {
                    this.m_revisions =new RevisionCollection(this);
                }
                returnthis.m_revisions;
            }
        }
 
        publicstring State
        {
            get
            {
                return(string)this[CoreField.State];
            }
            set
            {
                this[CoreField.State] = value;
            }
        }
 
        publicWorkItemStore Store
        {
            get
            {
                returnthis.m_store;
            }
        }
 
        publicint TemporaryId
        {
            get
            {
                returnthis.m_tempId;
            }
        }
 
        publicstring Title
        {
            get
            {
                return(string)this[CoreField.Title];
            }
            set
            {
                this[CoreField.Title] = value;
            }
        }
 
        publicWorkItemType Type
        {
            get
            {
                this.CheckUpdateCachedData();
                if(this.m_type ==null)
                {
                    thrownew WorkItemTypeDeniedOrNotExistException(string.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorWorkItemTypeNotExist,new object[] {string.Empty }));
                }
                returnthis.m_type;
            }
        }
 
        publicSystem.Uri Uri
        {
            get
            {
                TeamFoundationTrace.Verbose("Entering WorkItem.Uri/Get, id = {0}",new object[] {this.Id });
                ArtifactId artifactId =new ArtifactId();
                artifactId.ArtifactType ="WorkItem";
                artifactId.Tool ="WorkItemTracking";
                artifactId.ToolSpecificId =this.Id.ToString(CultureInfo.InvariantCulture);
                artifactId.VisualStudioServerNamespace =this.Store.TeamProjectCollection.Uri.AbsoluteUri;
                returnnew System.Uri(LinkingUtilities.EncodeUri(artifactId));
            }
        }
 
        publicWorkItemLinkCollection WorkItemLinkHistory
        {
            get
            {
                if(this.m_wlinksHistory ==null)
                {
                    this.m_wlinksHistory =new WorkItemLinkCollection(this, -4);
                }
                returnthis.m_wlinksHistory;
            }
        }
 
        publicWorkItemLinkCollection WorkItemLinks
        {
            get
            {
                if(this.m_wlinks ==null)
                {
                    this.m_wlinks =new WorkItemLinkCollection(this, -2);
                }
                returnthis.m_wlinks;
            }
        }
 
        privateclass BrieCallBack : IBrieCallBack
        {
            privateDictionary<int,bool=""> m_changes;
            privateWorkItemFieldData.FieldFlags m_flags;
            privateDictionary<int, workitemfielddata.fieldinfo=""> m_states;
            privateDictionary<int, workitemfielddata.fieldupdate=""> m_updates;
            privateWorkItem m_workitem;
 
            publicBrieCallBack(WorkItem wi)
            {
                this.m_workitem = wi;
                this.m_states =new Dictionary<int, workitemfielddata.fieldinfo="">();
                this.m_updates =new Dictionary<int, workitemfielddata.fieldupdate="">();
                this.m_changes =new Dictionary<int,bool="">();
                this.m_flags = WorkItemFieldData.FieldFlags.SetByRule;
            }
 
            intIBrieCallBack.GetTreeId(boololdValue)
            {
                objectfieldValue = this.m_workitem.GetFieldValue(-2, oldValue ? -3 : -2);
                if(fieldValue == null)
                {
                    return-1;
                }
                return(int) fieldValue;
            }
 
            objectIBrieCallBack.GetValue(intfieldId, boololdValue)
            {
                objectfieldValue;
                WorkItemFieldData.FieldUpdate update;
                if(!oldValue && (this.m_updates.TryGetValue(fieldId,out update) ||this.m_workitem.FieldData.GetUpdateFieldValue(fieldId,out update)))
                {
                    fieldValue = update.Value;
                }
                else
                {
                    fieldValue =this.m_workitem.GetFieldValue(fieldId, oldValue ? -3 : -2);
                }
                if(fieldValue isGuid)
                {
                    fieldValue = ((Guid) fieldValue).ToString();
                }
                returnfieldValue;
            }
 
            voidIBrieCallBack.InvalidateField(intfieldId)
            {
            }
 
            voidIBrieCallBack.SetProperties(intfieldId, BrieComputedFieldFlags externalFlags, BrieComputedFieldFlags suggestedFlags, BrieComputedFieldFlags requiredFlags, BrieComputedFieldFlags forbiddenFlags, BrieComputedFieldFlags requiredStatus, BrieComputedFieldFlags forbiddenStatus,string[] values,string[] formats,string[] forbiddenValues)
            {
                WorkItemFieldData.FieldFlags readOnly = 0;
                FieldDefinition definition =this.m_workitem.Store.FieldDefinitions.TryGetById(fieldId);
                if(definition != null)
                {
                    if(definition.IsComputed)
                    {
                        readOnly = WorkItemFieldData.FieldFlags.ReadOnly;
                    }
                    else
                    {
                        if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagSameAsBefore) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.ReadOnly;
                        }
                        if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagEmpty) != 0)
                        {
                            objectfieldValue = this.m_workitem.GetFieldValue(fieldId, -2);
                            if((fieldValue == null) || ((fieldValueis string) &&string.IsNullOrEmpty((string) fieldValue)))
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.ReadOnly;
                            }
                        }
                        if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagPattern) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.HasFormats;
                        }
                        if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagList) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.LimitedToValues;
                            if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagKeepEmpty) == 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.Required;
                            }
                        }
                        if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagPattern) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.LimitedToFormats;
                            if((requiredFlags & BrieComputedFieldFlags.ComputedFieldFlagKeepEmpty) == 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.Required;
                            }
                        }
                        if((forbiddenFlags & BrieComputedFieldFlags.ComputedFieldFlagEmpty) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.Required;
                        }
                        if((externalFlags & BrieComputedFieldFlags.ComputedFieldFlagList) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.HasValues;
                        }
                        if((externalFlags & BrieComputedFieldFlags.ComputedFieldFlagPattern) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.HasFormats;
                        }
                        if((externalFlags & BrieComputedFieldFlags.ComputedFieldFlagIncludeOldValue) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.AllowsOldValue;
                        }
                        if((requiredStatus | forbiddenStatus) != 0)
                        {
                            readOnly |= WorkItemFieldData.FieldFlags.InvalidRule;
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagEmpty) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidNotEmpty;
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagEmpty) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidEmpty;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagList) != 0)
                            {
                                if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagKeepEmpty) == 0)
                                {
                                    objectobj3 = this.m_workitem.GetFieldValue(fieldId, -2);
                                    if((obj3 == null) || ((obj3is string) &&string.IsNullOrEmpty((string) obj3)))
                                    {
                                        readOnly |= WorkItemFieldData.FieldFlags.InvalidEmpty;
                                    }
                                    else
                                    {
                                        readOnly |= WorkItemFieldData.FieldFlags.InvalidListValue;
                                    }
                                }
                                else
                                {
                                    readOnly |= WorkItemFieldData.FieldFlags.InvalidListValue;
                                }
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagList) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidListValue;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagPattern) != 0)
                            {
                                if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagKeepEmpty) == 0)
                                {
                                    objectobj4 = this.m_workitem.GetFieldValue(fieldId, -2);
                                    if((obj4 == null) || ((obj4is string) &&string.IsNullOrEmpty((string) obj4)))
                                    {
                                        readOnly |= WorkItemFieldData.FieldFlags.InvalidEmpty;
                                    }
                                    else
                                    {
                                        readOnly |= WorkItemFieldData.FieldFlags.InvalidFormat;
                                    }
                                }
                                else
                                {
                                    readOnly |= WorkItemFieldData.FieldFlags.InvalidFormat;
                                }
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagPattern) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidFormat;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagSameAsBefore) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidNotOldValue;
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagSameAsBefore) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidOldValue;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagEmptyOrSameAsBefore) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidNotEmptyOrOldValue;
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagEmptyOrSameAsBefore) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidEmptyOrOldValue;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagValueInOtherField) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidValueNotInOtherField;
                            }
                            if((forbiddenStatus & BrieComputedFieldFlags.ComputedFieldFlagValueInOtherField) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidValueInOtherField;
                            }
                            if((requiredStatus & BrieComputedFieldFlags.ComputedFieldFlagUnderlying) != 0)
                            {
                                readOnly |= WorkItemFieldData.FieldFlags.InvalidComputedField;
                            }
                        }
                    }
                    WorkItemFieldData.FieldInfo info =new WorkItemFieldData.FieldInfo();
                    info.Id = fieldId;
                    info.Flags = readOnly;
                    info.Values = values;
                    info.Formats = formats;
                    info.ProhibitedValues = forbiddenValues;
                    this.m_states[fieldId] = info;
                }
            }
 
            boolIBrieCallBack.SetValue(intfieldId, objectvalue)
            {
                WorkItemFieldData.FieldUpdate update;
                WorkItemFieldData.FieldFlags flags = WorkItemFieldData.FieldFlags.SetByRule |this.m_flags;
                FieldDefinition definition =this.m_workitem.Store.FieldDefinitions.TryGetById(fieldId);
                if((definition == null) || definition.IsComputed)
                {
                    returnfalse;
                }
                if((value is string) && (definition.SystemType != value.GetType()))
                {
                    try
                    {
                        value =this.m_workitem.FieldData.ConvertFromXml((string) value, definition.SystemType);
                    }
                    catch(FormatException)
                    {
                        flags |= WorkItemFieldData.FieldFlags.InvalidType;
                    }
                    catch(OverflowException)
                    {
                        flags |= WorkItemFieldData.FieldFlags.InvalidType;
                    }
                }
                if(this.m_updates.TryGetValue(fieldId,out update) && ((update.Flags & WorkItemFieldData.FieldFlags.SetByDefaultRule) == 0))
                {
                    returnfalse;
                }
                update =new WorkItemFieldData.FieldUpdate();
                update.Value = value;
                update.Flags = flags;
                this.m_updates[fieldId] = update;
                this.m_changes[fieldId] =true;
                returntrue;
            }
 
            publicDictionary<int,bool=""> ResetChanges()
            {
                Dictionary<int,bool=""> changes =this.m_changes;
                this.m_changes =new Dictionary<int,bool="">();
                returnchanges;
            }
 
            publicvoid SetFieldUpdateFlags(WorkItemFieldData.FieldFlags fieldFlags)
            {
                this.m_flags = fieldFlags;
            }
 
            publicDictionary<int, workitemfielddata.fieldinfo=""> FieldStates
            {
                get
                {
                    returnthis.m_states;
                }
            }
 
            publicDictionary<int, workitemfielddata.fieldupdate=""> FieldUpdates
            {
                get
                {
                    returnthis.m_updates;
                }
            }
        }
 
        internalenum EditAction
        {
            None,
            Revision,
            AddAttachment,
            DelAttachment,
            AddHyperLink,
            DelHyperLink,
            AddExternalLink,
            DelExternalLink,
            AddWorkItemLink,
            DelWorkItemLink
        }
 
        [Flags]
        internalenum EditActionFlags
        {
            AttachmentChanges = 2,
            ExternalLinkChanges = 8,
            FieldChanges = 1,
            HyperLinkChanges = 4,
            WorkItemLinkChanges = 0x10
        }
 
        [StructLayout(LayoutKind.Sequential)]
        internalstruct EditActionInfo
        {
            publicWorkItem.EditAction Action;
            publicDateTime ChangedDate;
            publicint ChangedBy;
            publicint Index;
        }
 
        privateclass EditActionInfoComparator : IComparer<workitem.editactioninfo>
        {
            privateWorkItem m_item;
 
            publicEditActionInfoComparator(WorkItem w)
            {
                this.m_item = w;
            }
 
            publicint Compare(WorkItem.EditActionInfo x, WorkItem.EditActionInfo y)
            {
                intnum = DateTime.Compare(x.ChangedDate, y.ChangedDate);
                if(num == 0)
                {
                    num = (int) (x.Action - y.Action);
                }
                if(((num == 0) && (x.ChangedBy != 0)) && (y.ChangedBy != 0))
                {
                    num = x.ChangedBy - y.ChangedBy;
                }
                if((num == 0) && ((x.Action == WorkItem.EditAction.AddWorkItemLink) || (x.Action == WorkItem.EditAction.DelWorkItemLink)))
                {
                    WorkItemLinkData.WorkItemLinkInfo actionObject = (WorkItemLinkData.WorkItemLinkInfo)this.m_item.GetActionObject(x);
                    WorkItemLinkData.WorkItemLinkInfo info2 = (WorkItemLinkData.WorkItemLinkInfo)this.m_item.GetActionObject(y);
                    num = actionObject.LinkType - info2.LinkType;
                    if(num == 0)
                    {
                        num = actionObject.TargetId - info2.TargetId;
                    }
                }
                returnnum;
            }
        }
 
        [StructLayout(LayoutKind.Sequential)]
        internalstruct EditActionSet
        {
            publicDateTime ChangedDate;
            publicint ChangedBy;
            publicstring Tag;
            publicstring Description;
            publicWorkItem.EditActionFlags Flags;
            publicArraySegment<workitem.editactioninfo> Actions;
        }
 
        privateenum OpenState
        {
            Undefined,
            New,
            Queried,
            PartiallyOpened,
            Opened,
            AccessDenied
        }
    }
}

[tfs] workitemtracking source code,布布扣,bubuko.com

[tfs] workitemtracking source code

原文：http://blog.csdn.net/wzhiu/article/details/21008959
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！