Key

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Internal\PropertyEditing\PropertyInspectorFontAndColorDictionary.cs (6)

32Add(keyValuePair.Key, new SolidColorBrush(color)); 47Add(keyValuePair.Key, new System.Windows.Media.LinearGradientBrush(startingColor, endingColor, 90)); 52Add(keyValuePair.Key, new FontFamily(drawingFontFamily.Name)); 54else if (keyValuePair.Key == "FontWeightKey") 56Add(keyValuePair.Key, System.Windows.FontWeights.Normal); 60Add(keyValuePair.Key, keyValuePair.Value);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Internal\PropertyEditing\State\PropertyViewManagerStateContainer.cs (1)

129sb.Append(PersistedStateUtilities.Escape(pair.Key));

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Interaction\Model\ModelItemDictionary.cs (7)

162return TryGetValue(item.Key, out value) && value == item.Value; 302keys[idx++] = kv.Key; 404Add(item.Key, item.Value); 423if (TryGetValue(item.Key, out value) && value == item.Value) { 424return Remove(item.Key); 447get { return new DictionaryEntry(_real.Current.Key, _real.Current.Value); } 451get { return _real.Current.Key; }

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Debugger\DebuggerService.cs (9)

540SourceLocation breakpointLocation = this.GetSourceLocationFromModelItem(entry.Key); 551breakpointLocations.Add(entry.Key, entry.Value); 630if (newSourceLocationMapping.ContainsKey(kvpEntry.Key)) 632newUnmappedBreakpoints.Add(newSourceLocationMapping[kvpEntry.Key], this.unmappedBreakpoints[kvpEntry.Value]); 652ModelItem modelItem = this.modelTreeManager.GetModelItem(kvp.Key); 663object unresolvedObject = unresolvedEntry.Key; 735this.modelItemToSourceLocation.Remove(resolvedEntry.Key); 737this.instanceToSourceLocationMapping.Remove(resolvedEntry.Key.GetCurrentValue()); 845foundElement = kvp.Key;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\DesignObjectWrapper.cs (2)

229content.Append(entry.Key); 235invalidProperties.Add(entry.Key);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\DictionaryItemsCollection.cs (1)

25ModelItemKeyValuePair<TKey, TValue> item = new ModelItemKeyValuePair<TKey, TValue>(kvpair.Key, kvpair.Value);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\DragDropHelper.cs (1)

624IMultipleDragEnabledCompositeView view2 = pair.Key as IMultipleDragEnabledCompositeView;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Metadata\ActivityArgumentHelper.cs (1)

191Assign remainingAssign = kvp.Key;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Model\ModelTreeManager.cs (3)

466ModelItem miKey = kvp.Key; 613this.OnPropertyEdgeRemoved(kvp.Key, modelProperty.Parent, kvp.Value); 1004edges.Add(new Edge(kvp.Key, vertex, kvp.Value));

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Model\WeakKeyDictionary.cs (6)

148Add(item.Key, item.Value); 165result = _internalDictionary.TryGetValue(new WeakKey(item.Key), out value); 183KeyValuePair<K, V> kv = new KeyValuePair<K, V>((K)item.Key.Target, item.Value); 192WeakKey key = new WeakKey(item.Key); 210object k = item.Key.Target; 221lostKeys.Add(item.Key);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\NamespaceHelper.cs (1)

157string importedNamespace = entries.Key;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\ObjectReferenceService.cs (1)

131objectReferenceId = kvp.Key;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\View\ParserContext.cs (1)

99.Select(p => p.Key)

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\View\TreeView\DesignerTreeViewItem.cs (1)

197builder.AppendFormat("{0}={1} ", item.Key, item.Value);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\View\TreeView\TreeViewItemKeyValuePairModelItemViewModel.cs (2)

80if (this.Value.Key != null) 82return this.Value.Key.GetEditingContext();

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\View\TreeView\UniqueModelItemHelper.cs (6)

88if (null != child.Key && !visited.Contains(child.Key)) 90visited.Add(child.Key); 91if (UniqueModelItemHelper.UniqueRoute(child.Key, target, expected)) 93retval.Add(child.Key); 168queue.Enqueue(kvp.Key);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\View\TypeResolvingOptions.cs (4)

96result.HintTextMap.Add(kvp.Key, kvp.Value); 155result.Add(kvp.Key, kvp.Value); 160if (!result.ContainsKey(kvp.Key)) 162result.Add(kvp.Key, kvp.Value);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\WorkflowViewElement.cs (3)

974if (pair.Key is IMultipleDragEnabledCompositeView) 976((IMultipleDragEnabledCompositeView)pair.Key).OnItemsMoved(pair.Value); 985pair.Key.OnItemMoved(pair.Value[0]);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Xaml\ErrorTolerantObjectWriter.cs (3)

1138result.Writer.WriteNamespace(new NamespaceDeclaration(ns.Value, ns.Key)); 1239if (!prefixes.Contains(pair.Key) && !namespaces.Contains(pair.Value)) 1242prefixes.Add(pair.Key);

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Xaml\ObjectToSourceLocationMapping.cs (2)

113return matchingMappingRecord.Value.Key; 229object sourceLocationObject = entry.Key;

fx\src\data\System\Data\Common\DbConnectionStringBuilder.cs (1)

270if (!connectionStringBuilder.CurrentValues.TryGetValue(entry.Key, out value) || !entry.Value.Equals(value)) {

fx\src\data\System\Data\Common\ObjectStorage.cs (4)

511tmp.Add(entry.Key, entry.Value); 546return ((x.Key == y.Key) && // same type 557return unchecked(obj.Key.GetHashCode() + obj.Value.ElementName.GetHashCode());

fx\src\data\System\Data\ProviderBase\DbConnectionFactory.cs (2)

422newConnectionPoolGroups.Add(entry.Key, entry.Value); 533newConnectionPoolGroups.Add(entry.Key, entry.Value);

fx\src\data\System\Data\ProviderBase\DbConnectionPoolGroup.cs (1)

280newPoolCollection.TryAdd(entry.Key, entry.Value);

fx\src\data\System\Data\SqlClient\SqlDependencyUtils.cs (1)

431notificationIdsToRemove.Add(entry.Key);

System\Data\Common\CommandTrees\DbCommandTree.cs (1)

133paramAttrs.Add("Name", param.Key);

System\Data\Common\CommandTrees\DbFunctionCommandTree.cs (1)

56paramNames.Add(paramInfo.Key);

System\Data\Common\CommandTrees\ExpressionBuilder\DbExpressionBuilder.cs (1)

1911DbExpressionBinding applyBinding = DbExpressionBuilder.BindAs(applyTemplate.Value, applyTemplate.Key);

System\Data\Common\CommandTrees\ExpressionBuilder\Internal\ArgumentValidation.cs (11)

587throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_GroupBy_KeyNotEqualityComparable(keyInfo.Key)); 590keyNames.Add(keyInfo.Key); 591columns.Add(new KeyValuePair<string, TypeUsage>(keyInfo.Key, keyInfo.Value.ResultType)); 598keyValidator.GetName = (keyInfo, idx) => keyInfo.Key; 610if (keyNames.Contains(aggInfo.Key)) 612throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_GroupBy_AggregateColumnExistsAsGroupColumn(aggInfo.Key)); 630columns.Add(new KeyValuePair<string, TypeUsage>(aggInfo.Key, aggInfo.Value.ResultType)); 636aggValidator.GetName = (aggInfo, idx) => aggInfo.Key; 1575columnTypes.Add(new KeyValuePair<string, TypeUsage>(columnValue.Key, columnValue.Value.ResultType)); 1580columnValidator.GetName = ((columnValue, idx) => columnValue.Key); 1742if (string.IsNullOrEmpty(element.Key))

System\Data\Common\CommandTrees\Internal\ExpressionCopier.cs (1)

154IEnumerable<EdmProperty> mappedProps = mappedPropInfo.Select(propInfo => new EdmProperty(propInfo.Key, propInfo.Value));

System\Data\Common\CommandTrees\Internal\ExpressionPrinter.cs (2)

204TreeNode paramNode = new TreeNode(paramInfo.Key); 288node.Text.Append(paramInfo.Key);

System\Data\Common\CommandTrees\Internal\XmlExpressionDumper.cs (1)

59_writer.WriteAttributeString(attr.Key, (null == attr.Value ? "" : attr.Value.ToString()));

System\Data\Common\EntitySql\SemanticAnalyzer.cs (7)

1275argTypes.Zip(aggArgTypes).All(types => types.Key == null && types.Value == null || TypeSemantics.IsStructurallyEqual(types.Key, types.Value)), 3655sr.CurrentScope.Add(kvp.Key, new ProjectionItemDefinitionScopeEntry(kvp.Value)); 3773Debug.Assert(aggregates.Any((aggregate) => String.CompareOrdinal(aggregate.Key, groupAggregateVarRef.VariableName) == 0), 4112projectionItems.ForEach(projectionItem => sr.CurrentScope.Add(projectionItem.Key, new ProjectionItemDefinitionScopeEntry(projectionItem.Value))); 4135sr.CurrentScope.Replace(projectionItems[0].Key, new SourceScopeEntry(source.Variable)); 4142DbVariableReferenceExpression projectionExpressionRef = projectionExpression.Value.ResultType.Variable(projectionExpression.Key);

System\Data\Common\EntitySql\SemanticResolver.cs (2)

1652updatedEntries.Add(new KeyValuePair<string, ScopeEntry>(scopeEntry.Key, newScopeEntry)); 1657updatedEntries.ForEach((updatedScopeEntry) => scope.Replace(updatedScopeEntry.Key, updatedScopeEntry.Value));

System\Data\Common\Internal\Materialization\ColumnMapKeyBuilder.cs (2)

108AppendValue("C", pair.Key); 234AppendValue(",K", typeChoice.Key);

System\Data\Common\Internal\Materialization\Shaper.cs (1)

116if (typeDelegatePair.Key == entityType)

System\Data\Common\Internal\Materialization\Translator.cs (3)

1453Expression discriminatorConstant = Expression.Constant(typeChoice.Key, discriminatorReader.Type); 1511Expression.Constant(typeChoice.Key), 1666ColumnMap propertyColumnMap = pair.Key;

System\Data\Common\QueryCache\EntityClientCacheKey.cs (1)

186sb.Append(param.Key);

System\Data\Common\Utils\AliasGenerator.cs (1)

77updatedCache.Add(entry.Key, entry.Value);

System\Data\Common\Utils\Boolean\ConversionContext.cs (3)

102_inverseVariableMap = _variableMap.ToDictionary(kvp => kvp.Value, kvp => kvp.Key); 180var successorVertex = vertexRange.Key; 196_inverseMap = _domainVariableToRobddVariableMap.ToDictionary(kvp => kvp.Value, kvp => kvp.Key);

System\Data\Common\Utils\MetadataHelper.cs (1)

828builder.AppendLine(view.Key);

System\Data\EntityClient\EntityCommand.cs (1)

589queryParams.Select(paramInfo => paramInfo.Value.Parameter(paramInfo.Key))).CommandTree;

System\Data\EntityClient\EntityCommandDefinition.cs (1)

332result.ParameterName = queryParameter.Key;

System\Data\EntityKey.cs (8)

890if (EntityUtil.IsNull(keyValuePair.Value) || String.IsNullOrEmpty(keyValuePair.Key)) 894ValidateName(keyValuePair.Key); 895keyNames[0] = tokenizeStrings ? EntityKey.LookupSingletonName(keyValuePair.Key) : keyValuePair.Key; 909if (EntityUtil.IsNull(keyValuePair.Value) || String.IsNullOrEmpty(keyValuePair.Key)) 914ValidateName(keyValuePair.Key); 915keyNames[i] = tokenizeStrings ? EntityKey.LookupSingletonName(keyValuePair.Key) : keyValuePair.Key;

System\Data\EntityModel\SchemaObjectModel\TypeUsageBuilder.cs (8)

157if (value.Key == EdmProviderManifest.StoreGeneratedPatternFacetName) 162else if (value.Key == EdmProviderManifest.ConcurrencyModeFacetName) 168value.Key == EdmProviderManifest.CollationFacetName) 177System.Data.Entity.Strings.FacetNotAllowed(value.Key, edmType.Name)); 278if (value.Key != EdmProviderManifest.NullableFacetName && 279value.Key != EdmProviderManifest.StoreGeneratedPatternFacetName && 280value.Key != EdmProviderManifest.ConcurrencyModeFacetName) 284System.Data.Entity.Strings.FacetNotAllowed(value.Key, schemaEnumType.FQName));

System\Data\Mapping\FunctionImportMapping.cs (2)

236Strings.Mapping_FunctionImport_UnreachableType(unreachableEntityType.Key.FullName, lines), 249string isTypeOfDescription = StorageMslConstructs.IsTypeOf + unreachableIsTypeOf.Key.FullName + StorageMslConstructs.IsTypeOfTerminal;

System\Data\Mapping\FunctionImportMappingNonComposable.cs (1)

227RowType rowType = new RowType(columns.Select(c => new EdmProperty(c.Key, c.Value)));

System\Data\Mapping\ObjectTypeMapping.cs (1)

172if (keyValuePair.Key.Equals(propertyName, StringComparison.OrdinalIgnoreCase))

System\Data\Mapping\StorageMappingItemCollection.cs (1)

437esqlViews.Add(extentViewPair.Key, generatedViews[0].eSQL);

System\Data\Mapping\StorageMappingItemCollection.ViewDictionary.cs (3)

149if (!resultDictionary.TryGetValue(keyValuePair.Key, out generatedView)) 152resultDictionary.Add(keyValuePair.Key, generatedView); 493string extentFullName = extentView.Key;

System\Data\Mapping\StorageMappingItemLoader.cs (2)

589violationNames.Add(mappingCount.Key.Name); 2528.All(ppm => ppm.Key.EdmEquals(ppm.Value.EdmProperty)), "propertyMappings order does not correspond to the order of properties in the structuredType.");

System\Data\Mapping\Update\Internal\DynamicUpdateCommand.cs (4)

57TryGetSetterExpression(tree, member.Key, op, out setter)) // can find corresponding setter 185if (identifierValues.TryGetValue(inputIdentifier.Key, out value)) 190m_inputIdentifiers[idx] = new KeyValuePair<int, DbSetClause>(inputIdentifier.Key, newClause); 261yield return inputIdentifier.Key;

System\Data\Mapping\Update\Internal\FunctionUpdateCommand.cs (7)

98yield return inputIdentifier.Key; 227if (identifierValues.TryGetValue(inputIdentifier.Key, out value)) 251.Select(r => new KeyValuePair<int, PropagatorResult>(GetColumnOrdinal(translator, reader, r.Key), r.Value)) 252.OrderBy(r => r.Key)) // order by column ordinal to avoid breaking SequentialAccess readers 254int columnOrdinal = resultColumn.Key; 399int thisIdentifier = this.m_inputIdentifiers[i].Key; 400int otherIdentifier = other.m_inputIdentifiers[i].Key;

System\Data\Mapping\Update\Internal\Graph.cs (2)

88yield return new KeyValuePair<TVertex, TVertex>(successors.Key, vertex); 221sb.AppendFormat(CultureInfo.InvariantCulture, "[{0}] --> ", outgoingEdge.Key);

System\Data\Mapping\Update\Internal\RelationshipConstraintValidator.cs (1)

181DirectionalRelationship expectedRelationship = expected.Key;

System\Data\Mapping\Update\Internal\UndirectedGraph.cs (2)

72if (componentMap[edge.Key].componentNum != componentMap[edge.Value].componentNum) { 75int newValue = componentMap[edge.Key].componentNum;

System\Data\Mapping\Update\Internal\UpdateCommandOrderer.cs (1)

355EntityKey key = keyAndCommands.Key;

System\Data\Mapping\Update\Internal\UpdateCompiler.cs (4)

335EdmProperty property = setClause.Key; 338GeneratePropertyExpression(target, setClause.Key), 339GenerateValueExpression(setClause.Key, setClause.Value))); 398DbExpression clauseExpression = GenerateEqualityExpression(target, clause.Key, clause.Value);

System\Data\Mapping\Update\Internal\UpdateTranslator.cs (4)

477if (PropagatorResult.NullIdentifier == generatedValue.Key.Identifier || 478!KeyManager.TryGetIdentifierOwner(generatedValue.Key.Identifier, out context)) 481context = generatedValue.Key; 869EntityKey key = required.Key;

System\Data\Mapping\ViewGeneration\BasicViewGenerator.cs (5)

337extentMap.RemoveKey(m.Key); 367var principalExtent = extentInfo.Key; 404var principalExtent = m.Key; 412extentLOJs[m.Key].Add(fkExtentLOJ); 423if (!nestedExtents.ContainsKey(m.Key))

System\Data\Mapping\ViewGeneration\DiscriminatorMap.cs (2)

148var discriminatorValues = typeMap.Select(map => map.Key); 171if (kv.Key.IsSubtypeOf(relProperty.FromEnd.TypeUsage.EdmType))

System\Data\Mapping\ViewGeneration\QueryRewriting\QueryRewriter.cs (2)

767CaseStatement newCaseStatement = new CaseStatement(entry.Key); 773newCaseStatements[entry.Key] = newCaseStatement;

System\Data\Mapping\ViewGeneration\Structures\MemberDomainMap.cs (2)

175var domainMap = m_conditionDomainMap.ToDictionary(p => p.Key, p => new Set<Constant>(p.Value, Constant.EqualityComparer)); 184var domainMap = m_conditionDomainMap.ToDictionary(p => p.Key, p => new Set<Constant>(p.Value, Constant.EqualityComparer));

System\Data\Mapping\ViewValidator.cs (1)

343return this.variableScopes.Where(it => (it.Key == expression.VariableName)).Select(it => it.Value).FirstOrDefault();

System\Data\Metadata\Edm\MetadataCollection.cs (1)

712this.IdentityDictionary.Add(pair.Key, pair.Value);

System\Data\Metadata\Edm\Provider\EdmProviderManifestFunctionBuilder.cs (1)

163FunctionParameter[] parameters = parameterDefinitions.Select(paramDef => CreateParameter(paramDef.Value, paramDef.Key)).ToArray();

System\Data\Metadata\MetadataCache.cs (1)

247cache.Remove(keysForRemoval[i].Key);

System\Data\Metadata\ObjectLayer\AssemblyCache.cs (2)

142entry.Key, new ImmutableAssemblyCacheEntry(entry.Value)); 152lockedAssemblyCache.Add(entry.Key, new ImmutableAssemblyCacheEntry(entry.Value));

System\Data\Metadata\ObjectLayer\ObjectItemConventionAssemblyLoader.cs (5)

95cspaceType = pair.Key; 101SessionData.EdmItemErrors.Add(new EdmItemError(Strings.Validator_OSpace_Convention_MultipleTypesWithSameName(type.Name), pair.Key)); 409var cp = typeToTrack.Key; 450var cp = typeToTrack.Key; 623var cp = typeToTrack.Key;

System\Data\Metadata\ObjectLayer\ObjectItemLoadingSessionData.cs (1)

88_conventionCSpaceTypeNames[edmType.Name] = new KeyValuePair<EdmType, int>(pair.Key, pair.Value + 1);

System\Data\Metadata\TypeHelpers.cs (1)

382rowElements.Add(new EdmProperty(kvp.Key, kvp.Value));

System\Data\Objects\DataClasses\EntityReference_TResultType.cs (1)

635retrievedProperties[constraint.FromProperties[i].Name].Key);

System\Data\Objects\ELinq\CompiledELinqQueryState.cs (2)

165ObjectParameter convertedParam = pair.Key.ShallowCopy(); 242.ToDictionary(pair => pair.Key, pair => pair.Value);

System\Data\Objects\ELinq\ELinqQueryState.cs (2)

154ObjectParameter convertedParam = pair.Key; 219ObjectParameter parameter = pair.Key;

System\Data\Objects\ELinq\ExpressionConverter.cs (1)

1580properties.Add(new EdmProperty(column.Key, column.Value.ResultType));

System\Data\Objects\ELinq\ReflectionUtil.cs (1)

438.ToDictionary(r => r.Key, r => r.Value);

System\Data\Objects\ELinq\Translator.cs (1)

466Type implementedCollection = implementedCollectionInfo.Key;

System\Data\Objects\EntityEntry.cs (4)

1713EntityReference reference = pair.Key as EntityReference; 2697this.SetCurrentEntityValue(pair.Key /*name*/, pair.Value.Key /*value*/); 2768if (!ByValueEqualityComparer.Default.Equals(valueCounterPair.Key, propertyValue))

System\Data\Objects\Internal\EntityProxyFactory.cs (2)

1179generator.Emit(OpCodes.Ldstr, navProperty.Key.RelationshipType.FullName); 1180generator.Emit(OpCodes.Ldstr, navProperty.Key.ToEndMember.Name);

System\Data\Objects\Internal\ObjectFullSpanRewriter.cs (2)

228DbExpression columnDef = expression.Property(nextInfo.Key); 245AssociationEndMember targetEnd = GetNavigationPropertyTargetEnd(nextInfo.Key);

System\Data\Objects\Internal\ObjectSpanRewriter.cs (1)

269columnDef = navSource.NavigateAllowingAllRelationshipsInSameTypeHierarchy(relSpan.Key, relSpan.Value);

System\Data\Objects\ObjectContext.cs (1)

2141builder.Append('\'').Append(item.Key.ConcatKeyValue()).Append('\'');

System\Data\Objects\ObjectStateManager.cs (15)

780if (pair.Key.RemoveFromCache(wrappedEntity, /*resetIsLoaded*/ false, /*preserveForeignKey*/ false)) 782pair.Key.OnAssociationChanged(CollectionChangeAction.Remove, wrappedEntity.Entity); 3144if (pair.Key.IsDependentEndOfReferentialConstraint(true) && pair.Value.Count > 0) 3153EntityReference reference = pair.Key as EntityReference; 3160pair.Key.RelationshipNavigation.To, 3161pair.Key.RelationshipNavigation.RelationshipName)); 3176if (pair.Key.IsForeignKey && (entry.State == EntityState.Unchanged || entry.State == EntityState.Modified)) 3180if (pair.Key.IsDependentEndOfReferentialConstraint(true) && pair.Value.Count > 0) 3188EntityReference reference = pair.Key as EntityReference; 3195pair.Key.RelationshipNavigation.To, 3196pair.Key.RelationshipNavigation.RelationshipName)); 3207addedRelationshipsByForeignKey.TryGetValue(pair.Key, out newFks); 3215addedRelationshipsByPrincipalKey.TryGetValue(pair.Key, out newFks); 3240if (deletedRelationshipsByForeignKey.TryGetValue(pair.Key, out removedKeys)) 3273retrievedProperties[constraint.FromProperties[i].Name].Key);

System\Data\Objects\RelationshipWrapper.cs (2)

46: this(extent, roleAndKey1.Key, roleAndKey1.Value, roleAndKey2.Key, roleAndKey2.Value)

System\Data\Query\InternalTrees\ColumnMap.cs (2)

428sb.AppendFormat(CultureInfo.InvariantCulture, "{0}({1},{2})", separator, kv.Key, kv.Value); 515sb.AppendFormat(CultureInfo.InvariantCulture, "{0}(<{1}>,{2})", separator, kv.Key, kv.Value);

System\Data\Query\InternalTrees\ColumnMapCopier.cs (1)

219newTypeChoices[kv.Key] = newMap;

System\Data\Query\InternalTrees\ColumnMapFactory.cs (1)

338return renameList == null || renameList.Count == 0 || !renameList.Any(m => m.Key == member.Name) ? member.Name : renameList[member.Name].GetRename(currentType);

System\Data\Query\InternalTrees\Dump.cs (4)

132_writer.WriteAttributeString(attr.Key, attr.Value.ToString()); 694attrs.Add("DiscriminatorValue", tc.Key); 716attrs.Add("EntityType", tc.Key); 1040attrs2.Add(kv.Key, kv.Value);

System\Data\Query\InternalTrees\ExplicitDiscriminatorMap.cs (2)

35m_properties = template.PropertyMap.Select(propertyValuePair => propertyValuePair.Key) 74result = discriminatorTypePair.Key;

System\Data\Query\InternalTrees\OpCopier.cs (3)

923Var outputVar = m_destCmd.CreateSetOpVar(kv.Key.Type); 926SetMappedVar(kv.Key, outputVar); 930rightMap.Add(outputVar, GetMappedVar((op.VarMap[1])[kv.Key]));

System\Data\Query\InternalTrees\Vars.cs (1)

616reverseMap[kv.Value] = kv.Key;

System\Data\Query\PlanCompiler\AggregatePushdown.cs (4)

893FindPathsToLeastCommonAncestor(candidate.Key, definingGroupNode, out functionAncestors, out groupByAncestors); 905FunctionOp functionOp = (FunctionOp)candidate.Key.Op; 941candidate.Key.Op = m_command.CreateVarRefOp(newFunctionVar); 942candidate.Key.Children.Clear();

System\Data\Query\PlanCompiler\ColumnMapTranslator.cs (2)

198columnMap = new ScalarColumnMap(varRefColumnMap.Type, varRefColumnMap.Name, commandAndColumn.Key, commandAndColumn.Value); 356newTypeChoices[kv.Key] = newTypeChoice;

System\Data\Query\PlanCompiler\ITreeGenerator.cs (6)

288throw EntityUtil.NotSupported(System.Data.Entity.Strings.ParameterTypeNotSupported(paramInfo.Key, paramInfo.Value.ToString())); 290_iqtCommand.CreateParameterVar(paramInfo.Key, paramInfo.Value); 1862typeFilter.ToEnumerable().Select(tf => tf.Value ? resultBinding.Variable.IsOfOnly(tf.Key) : resultBinding.Variable.IsOf(tf.Key)).ToList() 2208relPropertyList.Add(kv.Key); 2222EdmProperty property = propertyMap.Key;

System\Data\Query\PlanCompiler\JoinElimination.cs (1)

122m_varRemapper.AddMapping(kv.Key, kv.Value);

System\Data\Query\PlanCompiler\JoinGraph.cs (8)

1052if (orderedEdge1VarsEnumerator.Current.Key == orderedEdge2VarsEnumerator.Current.Key) 1063else if (orderedEdge1VarsEnumerator.Current.Key.Id > orderedEdge2VarsEnumerator.Current.Key.Id) 1102return edgeVars.OrderBy(kv => kv.Key.Id); 2303newVarMap[kv.Key] = newVar1; 2687result = ClassifyPredicate(targetNodeId, predicatePair.Key, predicatePair.Value, result, outPredicates); 2695result = ClassifyPredicate(targetNodeId, predicatePair.Key, predicatePair.Value, result, outPredicates);

System\Data\Query\PlanCompiler\NestPullup.cs (4)

1857Var keyDefiningVar = reverseMap[collectionVarDefinitionPair.Key]; 1869m_definingNodeMap.Add(collectionVarDefinitionPair.Key, newDefiningNode); 2222if (kv.Key != kv.Value) 2224varRefReplacementMap[kv.Key] = new VarRefColumnMap(kv.Value);

System\Data\Query\PlanCompiler\NominalTypeEliminator.cs (5)

625properties.Add(kv.Key); 1575newVarMap.Add(kv.Key, kv.Value); 1580if (!m_varInfoMap.TryGetVarInfo(kv.Key, out outerVarInfo)) 1582outerVarInfo = FlattenSetOpVar((SetOpVar)kv.Key); 2604object discriminatorValue = op.DiscriminatorMap.TypeMap[i].Key;

System\Data\Query\PlanCompiler\PropertyPushdownHelper.cs (3)

732if (TypeUtils.IsStructuredType(kv.Key.Type)) 741PropertyRefList myProps = GetPropertyRefList(kv.Key); 746AddPropertyRefs(kv.Key, myProps);

System\Data\Query\PlanCompiler\StructuredTypeInfo.cs (4)

346md.EntitySetBase set = setMapPair.Key; 580var entityType = (md.EntityType)kv.Key.EdmType; 586else if (kv.Value.IsRootType && (md.TypeSemantics.IsEntityType(kv.Key) || md.TypeSemantics.IsComplexType(kv.Key)))

System\Data\Query\PlanCompiler\TransformationRules.cs (2)

1581remapMap.Add(kv.Key, varRefNode); 3840trc.AddVarMapping(kv.Key, kv.Value);

System\Data\Query\PlanCompiler\VarRemapper.cs (2)

181newVarMap.Add(kv.Key, newVar); 186varMap.Add(kv.Key, kv.Value);

System\Data\Query\ResultAssembly\BridgeDataReader.cs (2)

131DbDataReader result = new BridgeDataReader(shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); 351SetShaper(nextResultShaperInfo.Key, nextResultShaperInfo.Value, depth: 0);

System\Data\SqlClient\SqlGen\Sql8ExpressionRewriter.cs (1)

466EdmProperty prop = rowExprType.Properties[column.Key];

System\Data\SqlClient\SqlGen\SqlGenerator.cs (1)

549paramsToForceNonUnicode = new HashSet<string>(_candidateParametersToForceNonUnicode.Where(p => p.Value).Select(q => q.Key).ToList());

System\Data\SqlClient\SqlProviderServices.cs (3)

116if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter)) { 123(paramsToForceNonUnicode.Contains(queryParameter.Key)) ) 132parameter = CreateSqlParameter(queryParameter.Key, parameterType, ParameterMode.In, DBNull.Value, preventTruncation, sqlVersion);

System\Data\Entity\Design\Common\MetadataItemSerializer.cs (1)

664_writer.WriteAttributeString("xmlns", xmlPrefixToNamespace.Key, null, xmlPrefixToNamespace.Value);

System\Data\Entity\Design\EntityModelSchemaGenerator.cs (2)

1077if (endMultiplicityOverride.Key != null && endMultiplicityOverride.Key == storeEndMember.Name)

System\Data\Entity\Design\EntityViewGeneration\EntityViewGenerator.cs (2)

457newDictionary.Add(GetExtentFullName(item.Key), item.Value); 519EntitySetBase entitySet = generatedViewPair.Key;

System\Data\EntityModel\Emitters\TypeReference.cs (2)

119string type = arguments.Key; 208string name = arguments.Key;

System\Data\EntityModel\Emitters\Utils.cs (1)

358if (pair.Key.Equals(name, comparison))

ChangeDirector.cs (1)

213TrackedObject rollbackItem = rollbackItemPair.Key;

DataServices.cs (1)

527object[] values = keys.OrderBy(kv => kv.Key.Ordinal).Select(kv => kv.Value).ToArray();

parent\Client\System\Data\Services\Client\BatchStream.cs (1)

302if (String.Equals(parameter.Key, XmlConstants.HttpMultipartBoundary, StringComparison.OrdinalIgnoreCase))

System\Data\Services\BatchServiceHost.cs (1)

95this.requestHeaders.Add(header.Key, header.Value);

System\Data\Services\HttpProcessUtility.cs (3)

337if (parameterInfo.Key == parameterName) 1083if (String.Equals(parameter.Key, XmlConstants.HttpQValueParameter, StringComparison.OrdinalIgnoreCase)) 1119if (String.Equals(parameter.Key, XmlConstants.HttpCharsetParameter, StringComparison.OrdinalIgnoreCase))

System\Data\Services\Providers\ObjectContextServiceProvider.cs (6)

310MetadataSerializer.WriteSchemaElement(xmlWriter, typesInNamespace.Key, metadataEdmSchemaVersion); 313if (!entityContainerDefinitionWritten && typesInNamespace.Key == this.Type.Namespace) 553ObjectStateEntry objectStateEntry = this.ObjectContext.ObjectStateManager.GetObjectStateEntry(objectToBeReplaced.Key); 558this.ObjectContext.Detach(objectToBeReplaced.Key); 648int propertyOrdinal = originalValues.GetOrdinal(etag.Key); 801Debug.Assert(containerEntry.Key != null, "containerEntry.Key != null");

System\Data\Services\Serializers\JsonSerializer.cs (1)

796this.WriteObjectOpenProperty(pair.Key, pair.Value, parentUri);

System\Data\Services\Serializers\MetadataSerializer.cs (4)

239Debug.Assert(!string.IsNullOrEmpty(namespaceAlongWithTypes.Key), "!string.IsNullOrEmpty(namespaceAlongWithTypes.Key)"); 244if (namespaceAlongWithTypes.Key == metadataManager.GetContainerNamespace()) 250Dictionary<string, ResourceAssociationType> associationsInThisNamespace = metadataManager.GetAssociationTypesForNamespace(namespaceAlongWithTypes.Key); 251MetadataSerializer.WriteSchemaElement(this.Writer, namespaceAlongWithTypes.Key, metadataEdmSchemaVersion);

System\Data\Services\Serializers\PlainXmlSerializer.cs (1)

311string propertyName = property.Key;

System\Data\Services\Serializers\SyndicationSerializer.cs (2)

344link.AttributeExtensions.Add(attributeExtension.Key, attributeExtension.Value); 872string propertyName = property.Key;

System\Data\Services\UpdateTracker.cs (2)

93MethodInfo[] methods = item.Key.ChangeInterceptors; 97parameters[0] = this.service.Updatable.ResolveResource(element.Key);

System\Data\Services\WebUtil.cs (12)

344if (valueType.InstanceType == mapping.Key) 353if (valueType.InstanceType == mapping.Key) 613if (type == primitiveTypeInfo.Key) 997types[i] = new ResourceType(PrimitiveTypesEdmNameMapping[i].Key, XmlConstants.EdmNamespace, name); 1540if (!RequestDescription.IsKnownRequestVersion(version.Key)) 1547string message = Strings.DataService_VersionNotSupported(version.Key.ToString(2), "1", "0' or '2.0"); 1554if (version.Key < requestDescription.RequireMinimumVersion) 1557version.Key.ToString(2), 1578if (version.Key < requestDescription.ResponseVersion) 1581version.Key.ToString(2), 1590if (version.Key < RequestDescription.DataServiceDefaultResponseVersion) 1593version.Key.ToString(2),

parent\Server\System\Data\Services\HttpProcessUtility.cs (1)

1119if (String.Equals(parameter.Key, XmlConstants.HttpCharsetParameter, StringComparison.OrdinalIgnoreCase))

System\Data\Services\Client\ALinq\NavigationPropertySingletonExpression.cs (1)

112this.CustomQueryOptions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value),

System\Data\Services\Client\ALinq\ReflectionUtil.cs (1)

450.ToDictionary(r => r.Key, r => r.Value);

System\Data\Services\Client\ALinq\ResourceBinder.cs (7)

201ResourceSetExpression target = predicates.Key; 287if (rse.KeyPredicate.Keys.Contains(g.Key)) 294rse.KeyPredicate.Add(g.Key, g.Value); 429Expression clause = Expression.Equal(Expression.Property(input, keyValue.Key), keyValue.Value); 939ResourceSetExpression newResource = new ResourceSetExpression(expressionType, source, memberExpression, resourceType, source.ExpandPaths.ToList(), source.CountOption, source.CustomQueryOptions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value), null); 948NavigationPropertySingletonExpression newResource = new NavigationPropertySingletonExpression(type, source, memberExpression, memberExpression.Type, source.ExpandPaths.ToList(), source.CountOption, source.CustomQueryOptions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value), null); 2318if (target.CustomQueryOptions.Any(c => (string)c.Key.Value == name))

System\Data\Services\Client\ALinq\ResourceSetExpression.cs (1)

221this.CustomQueryOptions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value),

System\Data\Services\Client\ALinq\UriWriter.cs (1)

259this.uriBuilder.Append(kvp.Key.Name);

System\Data\Services\Client\AtomMaterializerLog.cs (2)

116EntityDescriptor descriptor = new EntityDescriptor(entity.Key, entry.QueryLink, entry.EditLink, entry.ResolvedObject, null, null, null, entry.ETagText, EntityStates.Unchanged); 129this.context.TryGetEntity(entity.Key, entry.ETagText, this.mergeOption, out state);

System\Data\Services\Client\AtomParser.cs (2)

879Debug.Assert(callbackResult.Key != null, "callbackResult.Key != null"); 881this.reader = callbackResult.Key;

System\Data\Services\Client\BatchStream.cs (1)

302if (String.Equals(parameter.Key, XmlConstants.HttpMultipartBoundary, StringComparison.OrdinalIgnoreCase))

System\Data\Services\Client\ClientConvert.cs (1)

277return pair.Key;

System\Data\Services\Client\DataServiceContext.cs (1)

2273if (!Util.SupportedResponseVersions.Contains(version.Key))

System\Data\Services\Client\WebUtil.cs (3)

138if (string.Equals(header.Key, XmlConstants.HttpRequestAccept, StringComparison.Ordinal)) 145else if (string.Equals(header.Key, XmlConstants.HttpContentType, StringComparison.Ordinal)) 151request.Headers[header.Key] = header.Value;

System\Data\EntityModel\Emitters\EntityContainerEmitter.cs (6)

267var pairs = this.Generator.NamespaceMap.OrderByDescending(p => p.Key.Length).ThenBy(p => p.Key); 281new CodePrimitiveExpression(pair.Key), 301new CodePrimitiveExpression(pair.Key.Length) 328var reversePairs = Generator.NamespaceMap.OrderByDescending(p => p.Value.Length).ThenBy(p => p.Key); 350new CodePrimitiveExpression(pair.Key + "."),

System\Data\EntityModel\Emitters\TypeReference.cs (2)

111string type = arguments.Key; 171string name = arguments.Key;

System\Data\EntityModel\Emitters\Utils.cs (1)

338if (pair.Key.Equals(name, comparison))

System\Xml\Xsl\Xslt\QilGenerator.cs (1)

188ebTypes.Add(new EarlyBoundInfo(pair.Key, pair.Value));

System\Xml\Xsl\Xslt\XslAstAnalyzer.cs (3)

191AddImportDependencies(import, /*focusDonor:*/pair.Key); 240if (! parentModeFlags.TryGetValue(modeFlag.Key, out modeFlags)) { 243parentModeFlags[modeFlag.Key] = modeFlags | modeFlag.Value;

System\Xml\Xsl\Xslt\XsltInput.cs (3)

127if (scopeManager.LookupNamespace(prefixNamespacePair.Key) == null) { 129scopeManager.AddNsDeclaration(prefixNamespacePair.Key, nsAtomizedValue); 130ctxInfo.AddNamespace(prefixNamespacePair.Key, nsAtomizedValue);

System\IdentityModel\Protocols\WSTrust\WSTrust13RequestSerializer.cs (1)

235this.WriteXmlElement(writer, messageParam.Key, messageParam.Value, rst, context);

System\IdentityModel\Protocols\WSTrust\WSTrustSerializationHelper.cs (2)

699requestSerializer.WriteXmlElement(writer, messageParam.Key, messageParam.Value, rst, context); 1711responseSerializer.WriteXmlElement(writer, messageParam.Key, messageParam.Value, response, context);

System\IdentityModel\Tokens\SessionSecurityToken.cs (2)

1486if (!String.IsNullOrEmpty(property.Key) && !String.IsNullOrEmpty(property.Value)) 1491dictionaryWriter.WriteAttributeString(dictionary.ClaimPropertyName, dictionary.EmptyString, property.Key);

System\IO\Log\ReservationCollection.cs (1)

128FreeReservation(entry.Key);

System\Messaging\MessageQueue.cs (1)

4251newTable[kv.Key] = kv.Value;

System\Runtime\DurableInstancing\InstanceOwnerQueryResult.cs (1)

55owners.Add(metadata.Key, metadata.Value == null ? EmptyMetadata : safeMetadata);

System\Runtime\DurableInstancing\InstancePersistence.cs (7)

57if (property.Key == null) 63throw Fx.Exception.AsError(new InvalidOperationException(SRCore.MetadataCannotContainNullValue(property.Key))); 67throw Fx.Exception.AsError(new InvalidOperationException(SRCore.InitialMetadataCannotBeDeleted(property.Key))); 91copy.Add(value.Key, value.Value); 118copy.Remove(value.Key); 122copy[value.Key] = value.Value; 130copy.Remove(value.Key);

System\Runtime\DurableInstancing\InstancePersistenceContext.cs (2)

328InstanceKeyView view = new InstanceKeyView(keyMetadata.Key); 340InstanceKeyView view = new InstanceKeyView(keyMetadata.Key);

System\Runtime\DurableInstancing\InstanceView.cs (1)

85keys.Add(key.Key, key.Value.Clone());

System\Runtime\PersistencePipeline.cs (9)

90this.values.Add(value.Key, new InstanceValue(value.Value)); 94throw Fx.Exception.AsError(new InvalidOperationException(SRCore.NameCollisionOnCollect(value.Key, module.GetType().Name), exception)); 104this.values.Add(value.Key, new InstanceValue(value.Value, InstanceValueOptions.Optional | InstanceValueOptions.WriteOnly)); 108throw Fx.Exception.AsError(new InvalidOperationException(SRCore.NameCollisionOnCollect(value.Key, module.GetType().Name), exception)); 145this.values.Add(value.Key, new InstanceValue(value.Value, InstanceValueOptions.Optional | InstanceValueOptions.WriteOnly)); 149throw Fx.Exception.AsError(new InvalidOperationException(SRCore.NameCollisionOnMap(value.Key, writeOnlyValues.Item1.GetType().Name), exception)); 258this.keys = new List<XName>(this.basis.Where(value => value.Value.IsWriteOnly() == this.writeOnly).Select(value => value.Key)); 352if (!TryGetValue(item.Key, out value)) 374return this.basis.Where(value => value.Value.IsWriteOnly() == this.writeOnly).Select(value => new KeyValuePair<XName, object>(value.Key, value.Value.Value)).GetEnumerator();

System\Runtime\Serialization\CodeExporter.cs (5)

79string dataContractNamespace = pair.Key; 1001if (dataContract.StableName != pair.Key && !dataContract.KnownDataContracts.ContainsKey(pair.Key) && !pair.Value.IsBuiltInDataContract) 1002dataContract.KnownDataContracts.Add(pair.Key, pair.Value); 1386memberNames.Add(pair.Key, pair.Value);

System\Runtime\Serialization\CollectionDataContract.cs (1)

1502return new KeyValue<K, V>(current.Key, current.Value);

System\Runtime\Serialization\DataContractSet.cs (2)

49Add(pair.Key, pair.Value); 56ProcessedContracts.Add(pair.Key, pair.Value);

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (2)

72if (!stableNames.Contains(pair.Key)) 74stableNames.Add(pair.Key);

System\Runtime\Serialization\XmlObjectSerializerReadContext.cs (1)

959xmlAttributes.Add(AddNamespaceDeclaration(prefixNsPair.Key, prefixNsPair.Value));

System\ServiceModel\Administration\WbemProvider.cs (1)

883this.SetProperty(kv.Key, kv.Value);

System\ServiceModel\Channels\AddressHeaderCollection.cs (1)

139if (otherHeaders.TryGetValue(pair.Key, out count))

System\ServiceModel\Channels\ConnectionPool.cs (1)

105endpointKeysToRemove.Add(poolEntry.Key);

System\ServiceModel\Channels\ContextDictionary.cs (6)

114if (item.Key == null) 122ValidateKeyValueSpace(item.Key); 133if (item.Key == null) 142ValidateKeyValueSpace(item.Key); 177if (item.Key == null) 186ValidateKeyValueSpace(item.Key);

System\ServiceModel\Channels\ContextMessageHeader.cs (2)

163Fx.Assert(!string.IsNullOrEmpty(pair.Key), "ContextProperty name is null"); 165writer.WriteAttributeString(ContextPropertyNameAttribute, null, pair.Key);

System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

3325TryAddToCollection(addHeader, header.Key, value); 4217message.Properties.Add(property.Key, property.Value);

System\ServiceModel\Channels\HttpHeadersWebHeaderCollection.cs (6)

59return this.AllHeaders.Select(header => header.Key).ToArray(); 84collection.Add(header.Key, string.Empty); 90collection.Add(header.Key, value); 216return this.GetHeaderAt(index).Key; 235if (!string.IsNullOrEmpty(header.Key)) 237builder.Append(header.Key);

System\ServiceModel\Channels\HttpRequestMessageExtensionMethods.cs (4)

110bufferedHttpRequestMessage.Properties.Add(header.Key, value); 153if (!httpHeaders.TryAddWithoutValidation(header.Key, header.Value)) 157header.Key, 171string key = property.Key;

System\ServiceModel\Channels\MessageProperties.cs (7)

432this[property.Key] = property.Value; 773UpdateProperty(pair.Key, pair.Value, true); 783if (pair.Key == null) 786if (!TryGetValue(pair.Key, out value)) 845if (pair.Key == null) 849if (!TryGetValue(pair.Key, out value)) 857Remove(pair.Key);

System\ServiceModel\Channels\PnrpPeerResolver.cs (2)

661peerName, maxAddresses, targetScope, linkEntry.Key, linkEntry.Value, timeoutHelper.RemainingTime(), linkRegistrations); 672peerName, maxAddresses, targetScope, siteEntry.Key, siteEntry.Value, timeoutHelper.RemainingTime(), siteRegistrations);

System\ServiceModel\Channels\ReliableMessagingHelpers.cs (1)

724pair.Key.Abort();

System\ServiceModel\Channels\ReliableReplySessionChannel.cs (1)

660reply = pair.Key;

System\ServiceModel\Channels\UriPrefixTable.cs (2)

48this.RegisterUri(current.Key.BaseAddress, current.Key.HostNameComparisonMode, current.Value);

System\ServiceModel\Configuration\SecurityElementBase.cs (2)

500if (!b2.OperationSupportingTokenParameters.ContainsKey(operation1.Key)) 503SupportingTokenParameters stp2 = b2.OperationSupportingTokenParameters[operation1.Key];

System\ServiceModel\Description\DispatcherBuilder.cs (2)

687Uri listenUri = stuff.Key.ListenUri; 688ListenUriMode listenUriMode = stuff.Key.ListenUriMode;

System\ServiceModel\Description\ImportedPolicyConversionContext.cs (11)

67this.operationBindingAssertions[entry.Key].AddRange(new MaxItemsEnumerable<XmlElement>(entry.Value, remainingAssertionsAllowed)); 68remainingAssertionsAllowed -= this.operationBindingAssertions[entry.Key].Count; 73this.messageBindingAssertions[entry.Key].AddRange(new MaxItemsEnumerable<XmlElement>(entry.Value, remainingAssertionsAllowed)); 74remainingAssertionsAllowed -= this.messageBindingAssertions[entry.Key].Count; 79this.faultBindingAssertions[entry.Key].AddRange(new MaxItemsEnumerable<XmlElement>(entry.Value, remainingAssertionsAllowed)); 80remainingAssertionsAllowed -= this.faultBindingAssertions[entry.Key].Count; 263digits[i] = new KeyValuePair<K, IEnumerator<V>>(kvp.Key, kvp.Value.GetEnumerator()); 269counterValue[digits[i].Key] = digits[i].Value.Current; 287IEnumerator<V> newDigit = sets[digits[currentDigit].Key].GetEnumerator(); 288digits[currentDigit] = new KeyValuePair<K, IEnumerator<V>>(digits[currentDigit].Key, newDigit); 303counterValue[digits[i].Key] = digits[i].Value.Current;

System\ServiceModel\Description\WsdlImporter.cs (1)

2380string key = CreateKeyFromPolicy(policyDocument.Key, policyDocument.Value);

System\ServiceModel\Diagnostics\PerformanceCountersBase.cs (1)

172this.cache.Remove(entry.Key);

System\ServiceModel\Dispatcher\ActionMessageFilterTable.cs (3)

68entries[i++] = new Entry(item.Key, item.Value); 145Add(item.Key, item.Value); 476return Remove(item.Key);

System\ServiceModel\Dispatcher\AndMessageFilterTable.cs (2)

89this.Add(item.Key, item.Value); 444return Remove(item.Key);

System\ServiceModel\Dispatcher\DataContractSerializerOperationFormatter.cs (3)

310if (multipleHeaderValues[headerDescription.Index].Key == null) 341if (multipleHeaderValues[i].Key != null) 342parameters[i] = multipleHeaderValues[i].Value.ToArray(multipleHeaderValues[i].Key);

System\ServiceModel\Dispatcher\EndpointAddressMessageFilterTable.cs (5)

203Add(item.Key, item.Value); 212if (this.headerLookup.TryGetValue(item.Key, out bits)) 222this.headerLookup[item.Key] = bits; 232this.headerLookup.Add(item.Key, bits); 786return Remove(item.Key);

System\ServiceModel\Dispatcher\MessageFilter.cs (18)

84if (item.Key.Match(message)) 90f.Add(item.Key); 94filter = item.Key; 110if (item.Key.Match(buffer)) 116f.Add(item.Key); 120filter = item.Key; 134if (item.Key.Match(message)) 147if (item.Key.Match(buffer)) 160if (item.Key.Match(message)) 166f.Add(item.Key); 170filter = item.Key; 182if (item.Key.Match(buffer)) 188f.Add(item.Key); 192filter = item.Key; 204if (item.Key.Match(message)) 206results.Add(item.Key); 217if (item.Key.Match(buffer)) 219results.Add(item.Key);

System\ServiceModel\Dispatcher\MessageFilterTable.cs (4)

100entries[i++] = new Entry(item.Key, item.Value, GetPriority(item.Key)); 212this.Add(item.Key, item.Value); 577return this.Remove(item.Key);

System\ServiceModel\Dispatcher\MessageQueryTable.cs (2)

87this.Add(item.Key, item.Value); 167return this.Remove(item.Key);

System\ServiceModel\Dispatcher\QueryMatcher.cs (3)

177result.Key, (TResult)(object)result.Value.GetResultAsString())); 183result.Key, (TResult)(object)result.Value.GetResultAsBoolean())); 188result.Key, (TResult)(object)result.Value));

System\ServiceModel\Dispatcher\XPathMessageContext.cs (1)

131this.AddNamespace(ns.Key, ns.Value);

System\ServiceModel\Dispatcher\XPathMessageFilterTable.cs (3)

97entries[i++] = new Entry(item.Key, item.Value); 172this.Add(item.Key, item.Value); 580this.iqMatcher.Remove((XPathMessageFilter)item.Key);

System\ServiceModel\PeerResolvers\CustomPeerResolverService.cs (1)

652remove.Add(item.Key);

System\ServiceModel\Security\SecuritySessionFilter.cs (4)

203this.Add(item.Key, item.Value); 214return this.ContainsKey(item.Key); 229return this.Remove(item.Key); 390filter = matchingPair.Key;

System\ServiceModel\XamlIntegration\XPathMessageContextMarkupExtension.cs (1)

59context.AddNamespace(ns.Key, ns.Value);

System\UriTemplate.cs (16)

217string uppercaseKey = kvp.Key.ToUpperInvariant(); 221SR.GetString(SR.UTAdditionalDefaultIsInvalid, kvp.Key, this.originalTemplate)); 245this.additionalDefaults.Add(kvp.Key, kvp.Value); 561kvp.Value.Lookup(result.QueryParameters[kvp.Key], result.BoundVariables); 569result.BoundVariables.Add(kvp.Key, UnescapeDefaultValue(kvp.Value)); 868if (string.IsNullOrEmpty(kvp.Key)) 913if (extraParameters.TryGetValue(kvp.Key, out extraParameter)) 917extraParameters.Remove(kvp.Key); 926if (!extraParameters.ContainsKey(kvp.Key)) 928extraParameters.Add(kvp.Key, kvp.Value); 1020this.defaults.Add(kvp.Key, kvp.Value); 1027this.defaults.Add(kvp.Key.ToUpperInvariant(), kvp.Value); 1474if (!extraParameters.ContainsKey(kvp.Key)) 1476extraParameters.Add(kvp.Key, kvp.Value); 1643if (extraParameters.TryGetValue(kvp.Key, out extraParameter)) 1647extraParameters.Remove(kvp.Key);

System\UriTemplateHelpers.cs (3)

34string queryKeyName = kvp.Key; 268if (!queryVarNamesWithLiteralVals.ContainsKey(kvp.Key)) 270queryVarNamesWithLiteralVals.Add(kvp.Key, 0);

System\UriTemplateTable.cs (4)

379UriTemplate ut = kvp.Key; 577ThrowIfInvalid(kvp.Key, "keyValuePairs"); 584ThrowIfInvalid(item.Key, "item"); 589ThrowIfInvalid(item.Key, "item");

System\UriTemplateTrieNode.cs (13)

62UriTemplate ut = kvp.Key; 164candidates.Add(new UriTemplateTableMatchCandidate(answer.Items[i].Key, answer.SegmentsCount, 384SR.UTTDuplicate, pesLists[i][0].Items[0].Key.ToString(), pesLists[i][1].Items[0].Key.ToString()))); 455Fx.Assert(pes.Items[i].Key.IsPathPartiallyEquivalentAt(pes.Items[i + 1].Key, pes.SegmentsCount), 465if (pes.SegmentsCount < kvp.Key.segments.Count) 470a[arrayIndex++] = kvp.Key; 485return node.endOfPath.Items[0].Key; 489return node.finalVariableSegment.Items[0].Key; 493return node.star.Items[0].Key; 500return pes.Items[0].Key; 506return pes.Items[0].Key;

System\ServiceModel\Activation\HostedHttpContext.cs (1)

140result.AppendHeader(header.Key, value);

System\ServiceModel\Activities\Dispatcher\CorrelationKeyCalculator.cs (9)

102if (!(result.Key is OptionalMessageQuery)) 109values.Add(select.Select[result.Key], result.Value); 145if (!(result.Key is OptionalMessageQuery)) 152values.Add(item.Value[result.Key], result.Value); 165additionalKey = new CorrelationKey(values, this.parent.scopeName.ToString(), null) { Name = item.Key }; 209keyValueAsString.Append(pair.Key).Append(":").Append(pair.Value).Append(','); 337this.key = keyValue.Key; 369int hash1 = CombineHashCodes(this.hashCode, keyValue.Key.GetHashCode()); 385if (!this.keyValues.TryGetValue(targetKeyValue.Key, out sourceValue) ||

System\ServiceModel\Activities\Dispatcher\DurableInstanceManager.cs (9)

80if (this.instanceOwnerMetadata.ContainsKey(property.Key)) 82throw FxTrace.Exception.Argument("readWriteValues", SR.ConflictingValueName(property.Key)); 84this.instanceOwnerMetadata.Add(property.Key, new InstanceValue(property.Value)); 92if (this.instanceOwnerMetadata.ContainsKey(property.Key)) 94throw FxTrace.Exception.Argument("writeOnlyValues", SR.ConflictingValueName(property.Key)); 96this.instanceOwnerMetadata.Add(property.Key, new InstanceValue(property.Value, 110if (this.instanceMetadataChanges.ContainsKey(pair.Key)) 112throw FxTrace.Exception.Argument("writeOnlyValues", SR.ConflictingValueName(pair.Key)); 114this.instanceMetadataChanges.Add(pair.Key, new InstanceValue(pair.Value, InstanceValueOptions.Optional | InstanceValueOptions.WriteOnly));

System\ServiceModel\Activities\Dispatcher\PersistenceContext.cs (1)

698saveCommand.InstanceMetadataChanges.Add(pair.Key, pair.Value);

System\ServiceModel\Activities\Dispatcher\WorkflowServiceInstance.cs (2)

1528data[WorkflowNamespace.VariablesPath.GetName(mappedVariable.Key)] = new InstanceValue(mappedVariable.Value, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional); 1561data[WorkflowNamespace.OutputPath.GetName(output.Key)] = new InstanceValue(output.Value, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);

System\ServiceModel\Activities\InitializeCorrelation.cs (1)

61dictionary.Add(pair.Key, pair.Value.Get(context));

System\ServiceModel\Activities\InternalSendMessage.cs (3)

1370if (localLastUsedCacheItem.Key != null && localLastUsedCacheItem.Key.TryAddReference()) 1372cacheItem = localLastUsedCacheItem.Key;

System\ServiceModel\Activities\ReceiveParametersContent.cs (4)

79this.argumentNames[index] = pair.Key; 111RuntimeArgument newRuntimeArgument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out); 123requestFormatter.Parameters.Add(OutArgument.CreateReference(parameter.Value, parameter.Key)); 132responseFormatter.Parameters.Add(OutArgument.CreateReference(parameter.Value, parameter.Key));

System\ServiceModel\Activities\SendParametersContent.cs (4)

95this.argumentNames[index] = pair.Key; 127RuntimeArgument newRuntimeArgument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.In); 141requestFormatter.Parameters.Add(InArgument.CreateReference(parameter.Value, parameter.Key)); 151responseFormatter.Parameters.Add(InArgument.CreateReference(parameter.Value, parameter.Key));

System\ServiceModel\Activities\SerializableInstanceKey.cs (2)

28this.metadata.Add(pair.Key, new SerializableInstanceValue(pair.Value)); 78metadata.Add(pair.Key, pair.Value.ToInstanceValue());

System\ServiceModel\Activities\WorkflowService.cs (2)

306if (constrants.Key != null && constrants.Value != null) 308clonedSettings.AdditionalConstraints.Add(constrants.Key, new List<Constraint>(constrants.Value));

System\ServiceModel\MessageQuerySet.cs (1)

55destination.Add(vkpair.Value, vkpair.Key);

System\ServiceModel\Channels\MessageExtensionMethods.cs (2)

124string.Equals(property.Key, MessageHeadersPropertyKey, StringComparison.Ordinal)) 133message.Properties.Add(property.Key, property.Value);

System\Runtime\Collections\NullableKeyDictionary.cs (3)

142Add(item.Key, item.Value); 154if (item.Key == null) 182if (item.Key == null)

System\Runtime\Collections\ObjectCache.cs (1)

265this.cacheItems.Remove(expiredItems[i].Key);

System\Runtime\Collections\OrderedDictionary.cs (6)

31this.privateDictionary.Add(pair.Key, pair.Value); 121Add(item.Key, item.Value); 141if (item.Key == null || !this.privateDictionary.Contains(item.Key)) 147return this.privateDictionary[(object)item.Key].Equals(item.Value); 203this.privateDictionary.Remove(item.Key);

System\ServiceModel\Dispatcher\StrictAndMessageFilter.cs (2)

266this.Add(item.Key, item.Value); 287return this.andFilters.Remove(item.Key);

System\ServiceModel\WasHosting\MetabaseSettingsIis7.cs (2)

89this.Bindings.Add(entry.Key, entry.Value.ToArray()); 425this.Bindings.Add(entry.Key, entry.Value.ToArray());

System\ServiceModel\Dispatcher\UriTemplateClientFormatter.cs (1)

70nvc[this.queryMapping[i].Key] = this.qsc.ConvertValueToString(parameters[i], this.queryMapping[i].Value);

System\ServiceModel\Dispatcher\UriTemplateDispatchFormatter.cs (2)

78string queryVal = nvc[this.queryMapping[i].Key]; 96if (String.Compare(key, kvp.Key, StringComparison.OrdinalIgnoreCase) == 0)

System\ServiceModel\Dispatcher\WebHttpDispatchOperationSelector.cs (4)

261if (pair.Key == method || pair.Key == WebHttpBehavior.WildcardMethod) 276if (!allowedMethods.Contains(pair.Key)) 278allowedMethods.Add(pair.Key);

Compilation\BuildManagerHost.cs (1)

316return pair.Key;

Compilation\BuildProvidersCompiler.cs (2)

798CacheCompileErrors(pair.Key, pair.Value); 801CacheAssemblyResults(pair.Key, pair.Value);

Configuration\FolderLevelBuildProviderCollection.cs (1)

101if ((pair.Key & appliesTo) != 0) {

Hosting\ApplicationManager.cs (1)

1221appDomain.SetData(entry.Key, entry.Value);

Hosting\HostingEnvironment.cs (1)

494setter(sw.Key, sw.Value);

Hosting\ProcessHost.cs (1)

1177if (String.Equals(copiedError.Key, appId, StringComparison.OrdinalIgnoreCase)) {

ModelBinding\CollectionModelBinderUtil.cs (2)

32if (element.Key != null) { 33dictionary[element.Key] = element.Value;

ModelBinding\DictionaryHelpers.cs (1)

15string key = entry.Key;

ModelBinding\DictionaryValueProvider`1.cs (1)

24_values[entry.Key] = new ValueProviderResult(rawValue, attemptedValue, culture);

ModelBinding\ModelStateDictionary.cs (2)

21_innerDictionary.Add(entry.Key, entry.Value); 131this[entry.Key] = entry.Value;

ModelBinding\MutableObjectModelBinder.cs (2)

163missingRequiredProperties.ExceptWith(complexModel.Results.Select(r => r.Key.PropertyName)); 172ModelMetadata propertyMetadata = entry.Key;

Routing\ParsedRoute.cs (8)

84if (!acceptedValues.ContainsKey(newValue.Key)) { 85acceptedValues.Add(newValue.Key, newValue.Value); 92string parameterName = currentValue.Key; 142if (values.TryGetValue(defaultValue.Key, out value)) { 143unusedNewValues.Remove(defaultValue.Key); 307unusedNewValues.Remove(constraintsItem.Key); 484if (!matchedValues.ContainsKey(defaultValue.Key)) { 485matchedValues.Add(defaultValue.Key, defaultValue.Value);

Routing\Route.cs (4)

112routeData.Values.Add(value.Key, value.Value); 118routeData.DataTokens[prop.Key] = prop.Value; 145vpd.DataTokens[prop.Key] = prop.Value; 178if (!ProcessConstraint(httpContext, constraintsItem.Value, constraintsItem.Key, values, routeDirection)) {

Routing\RouteCollection.cs (1)

346_namedMap.Remove(namedRoute.Key);

UI\TemplateControl.cs (1)

437string key = entry.Key;

UI\WebControls\Content.cs (1)

111attribs[pair.Key] = pair.Value;

UI\WebControls\MethodParametersDictionary.cs (2)

74names[i] = kvp.Key; 166Add(item.Key, item.Value);

UI\WebParts\PersonalizationStateInfoCollection.cs (1)

142al.Add(de.Key);

DynamicData\ControlFilterExpression.cs (1)

140string parameterName = entry.Key;

DynamicData\DynamicControl.cs (1)

198var propInfo = ucType.GetProperty(entry.Key, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);

DynamicData\DynamicHyperLink.cs (2)

221string key = entry.Key; 230routeValues[pk.Key] = pk.Value;

System\Data\WebControls\EntityDataSourceWrapper.cs (2)

182var groups = referenceList.GroupBy(r => r.Key.Group); 191EntityDataSourceReferenceKeyColumn column = reference.Key;

ApplicationServices\ProfileService.cs (3)

137string propertyName = entry.Key; 176string propertyName = kvp.Key; 207SettingsPropertyValue value = GetPropertyValue(pb, kvp.Key);

ClientServices\Providers\ClientSettingsProvider.cs (1)

546SettingsProperty setting = _Properties[(string) de.Key];

Profile\ProfileService.cs (2)

58propertyName = entry.Key; 94string propertyName = entry.Key;

Script\Services\WebServiceMethodData.cs (1)

189string memberName = pair.Key;

UI\PageRequestManager.cs (2)

763if (ControlUtil.IsBuiltInHiddenField(entry.Key)) { 764EncodeString(writer, HiddenFieldToken, entry.Key, entry.Value);

UI\ProfileServiceManager.cs (1)

227sb.Append(group.Key); // group name

UI\ScriptComponentDescriptor.cs (3)

181builder.Append(HttpUtility.JavaScriptStringEncode(e.Key)); 209builder.Append(HttpUtility.JavaScriptStringEncode(p.Key)); 242builder.Append(HttpUtility.JavaScriptStringEncode(p.Key));

UI\ScriptResourceAttribute.cs (1)

247builder.Append(HttpUtility.JavaScriptStringEncode(res.Key));

UI\WebControls\Expressions\PropertyExpression.cs (2)

20if (!String.IsNullOrEmpty(pair.Key)) { 22Expression property = ExpressionHelper.CreatePropertyExpression(parameterExpression, pair.Key);

UI\WebControls\QueryableDataSourceHelper.cs (3)

137string key = parameter.Key; 182string key = parameter.Key; 209string name = parameter.Key;

Util\OrderedDictionary.cs (2)

122Add(item.Key, item.Value); 139RemoveFromLists(item.Key);

misc\GDI\WindowsGraphicsCacheManager.cs (1)

157if (WindowsFontCache[index].Key.Equals(font)) // don't do shallow comparison, we could miss cloned fonts.

Rules\Parser\Parser.cs (2)

987string key = kvp.Key; 1001string key = kvp.Key;

Rules\Parser\Scanner.cs (2)

96if (char.ToUpper(kvp.Key[0], CultureInfo.InvariantCulture) == upperFirstCharacter) 97list.Add(new IntellisenseKeyword(kvp.Key));

Rules\References.cs (1)

69symbolList.Add(pair.Key);

StateMachineSubscriptionManager.cs (1)

336subscriptions.Add(dictionaryEntry.Key, dictionaryEntry.Value);

AuthoringOM\ActivityExecutionContext.cs (1)

491cachedGrantedLocks.Add(grantedLockEntry.Key, (GrantedLock)grantedLockEntry.Value.Clone());

AuthoringOM\Compiler\TypeSystem\TypeProvider.cs (2)

877needRefreshCompileUnits2.Add(entry.Key, entry.Value); 882CodeDomLoader codeDomLoader = this.compileUnitLoaders[entry.Key] as CodeDomLoader;

AuthoringOM\DependencyObject.cs (3)

534if (keyValuePair.Key != ParentDependencyObjectProperty && originalObject.DependencyPropertyValues.ContainsKey(keyValuePair.Key)) 536object originalPropValue = originalObject.DependencyPropertyValues[keyValuePair.Key];

AuthoringOM\Design\ActivityDesigner.cs (1)

806string ruleName = rule.Key as string;

AuthoringOM\Serializer\ActivitySurrogate.cs (2)

53if (kvp.Key != null && !kvp.Key.DefaultMetadata.IsNonSerialized)

AuthoringOM\Serializer\DependencyStoreSurrogate.cs (4)

27if (!kvp.Key.DefaultMetadata.IsNonSerialized) 29if (kvp.Key.IsKnown) 30properties.Add(kvp.Key.KnownIndex); 32properties.Add(kvp.Key);

Hosting\SharedConnectionWorkflowTransactionService.cs (1)

143WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Removing transaction " + kvp.Key.GetHashCode());

RTTrackingProfile.cs (9)

146_activities.Add(kvp.Key, runtimeProfile._activities[kvp.Key]); 155_dynamicActivities.Add(kvp.Key, runtimeProfile._dynamicActivities[kvp.Key]); 164_user.Add(kvp.Key, runtimeProfile._user[kvp.Key]); 173_dynamicUser.Add(kvp.Key, kvp.Value); 393_activities.Add(kvp.Key, kvp.Value); 400_user.Add(kvp.Key, kvp.Value);

System\Activities\Statements\Interop.cs (2)

449if (this.properties.TryGetValue(output.Key, out argument) && argument != null) 477arguments.Add(parameter.Key, argument.Get<object>(context));

System\Activities\Statements\InteropEnvironment.cs (1)

275bookmarksToRemove.Add(entry.Key);

System\Activities\Statements\InteropExecutor.cs (3)

475string truncatedName = input.Key.Substring(0, input.Key.Length - suffixLength); 480propertyInfo = definition.GetType().GetProperty(input.Key);

Tracking.cs (2)

225_toRemove.Add(kvp.Key); 962Guid previous = HashHelper.HashServiceType(replacement.Key);

Tracking\SqlTrackingService.cs (3)

1852command.Parameters.Add(DbResourceAllocator.NewDbParameter("@EventId" + index, kvp.Key)); 1922command.Parameters.Add(DbResourceAllocator.NewDbParameter("@TrackingDataItemId" + index, kvp.Key)); 1986command.Parameters.Add(DbResourceAllocator.NewDbParameter("@EventId" + index, kvp.Key));

Tracking\SqlTrackingWorkflowInstance.cs (1)

555cmd.Parameters.Add(new SqlParameter("@WorkflowInstanceEventId", kvp.Key));

WorkBatch.cs (5)

135_pendingWorkCollection.Add(item.Key, kvp.Key, kvp.Value); 206IPendingWork work = workItem.Key; 250IPendingWork work = workItem.Key; 261IPendingWork work = workItem.Key;

WorkflowQueuingService.cs (11)

339WorkflowTrace.Runtime.TraceInformation("Queuing Service: Processing delayed message notification '{0}'", pair.Key.ToString()); 343if (service.persistedQueueStates.ContainsKey(pair.Key)) 345EventQueueState qState = service.GetQueue(pair.Key); 348service.NotifyAsynchronousSubscribers(pair.Key, qState, 1); 352NotifyAsynchronousSubscribers(pair.Key, pair.Value, 1); 478if (this.persistedQueueStates.ContainsKey(mergeItem.Key)) 480EventQueueState oldvalue = this.persistedQueueStates[mergeItem.Key]; 486string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.QueueBusyException, new object[] { mergeItem.Key }); 491modifiedItems.Add(mergeItem.Key, mergeItem.Value); 500this.persistedQueueStates[modifiedItem.Key] = modifiedItem.Value; 720persistedQueueStatesSnapshot.Add(kv.Key, individualPersistedQueueStateValue);

WorkflowStateRollbackService.cs (1)

117Activity oldActivity = batch.Key as Activity;

System\ServiceModel\Dispatcher\WorkflowOperationAsyncResult.cs (1)

318context.Context[contextElement.Key] = contextElement.Value;

System\Workflow\Activities\ReceiveActivity.cs (2)

1463this.notNullableParameters.Keys.Contains(parameterInfo.Key)) 1467activity.Name, parameterInfo.Value, this.notNullableParameters[parameterInfo.Key])));

System\Workflow\Activities\SendActivity.cs (2)

671inputs[parameterInfo.Key] = bindings[parameterInfo.Value].Value; 706bindings[parameterInfo.Value].Value = outputs[parameterInfo.Key];

System\Workflow\Runtime\Hosting\ChannelManager.cs (1)

216ChannelManagerHelpers.CreateChannelFactory(endpointData.Key, endpointData.Value, this.endpoints),

System\Xml\Dom\DocumentSchemaValidator.cs (1)

425defaultPrefix = pair.Key;

System\Xml\Schema\SchemaInfo.cs (4)

300if (!elementDecls.ContainsKey(entry.Key)) { 301elementDecls.Add(entry.Key, entry.Value); 305if (!elementDeclsByType.ContainsKey(entry.Key)) { 306elementDeclsByType.Add(entry.Key, entry.Value);

System\Xml\Schema\XmlSchemaValidator.cs (1)

1798defaultPrefix = pair.Key;

System\Xml\Serialization\CodeGenerator.cs (1)

2574Tuple<Type, string> key = new Tuple<Type, string>(item.Value.LocalType, item.Key);

System\Xml\Serialization\Types.cs (2)

1023replaceList.Add(pair.Key, replacedInfo); 1031memberInfos[pair.Key] = pair.Value;

System\Xml\XPath\XPathNavigator.cs (2)

1658if( pair.Key != "xmlns" ) 1659mngr.AddNamespace( pair.Key, pair.Value );

Base\MS\Internal\ContentType.cs (1)

255if (contentTypeEnumerator.Current.Key != null)

Base\MS\Internal\IO\Packaging\PartBasedPackageProperties.cs (3)

875PackageXmlEnum propertyNamespace = PackageXmlStringTable.GetXmlNamespace(entry.Key); 877_xmlWriter.WriteStartElement(PackageXmlStringTable.GetXmlString(entry.Key), 919_propertyDictionary[entriesToNullify[i].Key] = null;

Base\MS\Internal\Security\RightsManagement\IssuanceLicense.cs (3)

180AddNameDescription(nameDescriptionEntry.Key, nameDescriptionEntry.Value); 189AddApplicationSpecificData(applicationSpecificDataEntry.Key, applicationSpecificDataEntry.Value); 365unsignedPublishLicense.ApplicationSpecificDataDictionary.Add(appSpecificDataEntry.Value.Key, appSpecificDataEntry.Value.Value);

Base\System\Windows\Markup\XmlCompatibilityReader.cs (1)

153keysToUpdate.Add(pair.Key);

Base\System\Windows\NameScope.cs (6)

265if (item.Value != this[item.Key]) 269return Remove(item.Key); 274if (item.Key == null) 283Add(item.Key, item.Value); 288if (item.Key == null) 292return ContainsKey(item.Key);

Microsoft\Build\Tasks\Xaml\AttributeData.cs (1)

80attributeData.Properties.Add(propertyInfo.Key, propertyInfo.Value);

Microsoft\Build\Tasks\Xaml\ClassGenerator.cs (1)

228arguments[i] = new CodeAttributeArgument(propertyEntry.Key, GetCodeExpressionForAttributeArgument(attrib, propertyEntry.Value, classData));

Microsoft\Build\Tasks\Xaml\XamlBuildTypeInspectionExtensionContext.cs (1)

38this.markupItemsByTypeName.Add(markupItemByTypeName.Key, markupItemByTypeName.Value);