Char

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

2456bamlType.DefaultConstructor = delegate() { return new System.Char(); };

microsoft\win32\oavariantlib.cs (1)

system\boolean.cs (2)

210if (!Char.IsWhiteSpace(value[start]) && value[start] != nullChar) { 217if (!Char.IsWhiteSpace(value[end]) && value[end] != nullChar) {

system\char.cs (12)

29, IComparable<Char>, IEquatable<Char> 113if (!(obj is Char)) { 116return (m_value==((Char)obj).m_value); 120public bool Equals(Char obj) 136if (!(value is Char)) { 140return (m_value-((Char)value).m_value); 144public int CompareTo(Char value) { 152return Char.ToString(m_value); 158return Char.ToString(m_value); 187public static bool TryParse(String s, out Char result) { 932return (Char.ToString((char)utf32));

system\convert.cs (15)

120(RuntimeType)typeof(Char), 518if (value < 0 || value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char")); 525if (value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char")); 531if (value < 0 || value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char")); 538if (value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char")); 1823return Char.ToString(value); 2355fixed (Char* sPtr = s) { 2371public static Byte[] FromBase64CharArray(Char[] inArray, Int32 offset, Int32 length) { 2401fixed (Char* inArrayPtr = inArray) { 2420private static unsafe Byte[] FromBase64CharPtr(Char* inputPtr, Int32 inputLength) { 2474private static unsafe Int32 FromBase64_Decode(Char* startInputPtr, Int32 inputLength, Byte* startDestPtr, Int32 destLength) { 2492Char* inputPtr = startInputPtr; 2496Char* endInputPtr = inputPtr + inputLength; 2654private static unsafe Int32 FromBase64_ComputeResultLength(Char* inputPtr, Int32 inputLength) { 2661Char* inputEndPtr = inputPtr + inputLength;

system\diagnostics\eventing\eventsource.cs (1)

6819while (i < eventMessage.Length && Char.IsDigit(eventMessage[i]))

System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs (4)

306: TraceLoggingTypeInfo<Char> 316public override void WriteData(TraceLoggingDataCollector collector, ref Char value) 578: TraceLoggingTypeInfo<Char[]> 588public override void WriteData(TraceLoggingDataCollector collector, ref Char[] value)

System\Diagnostics\Eventing\TraceLogging\Statics.cs (2)

637else if (elementType == typeof(Char)) 749else if (dataType == typeof(Char))

system\enum.cs (3)

94UInt16 result = (UInt16)(Char)value; 395if (Char.IsDigit(value[0]) || value[0] == '-' || value[0] == '+') 942if (underlyingType == typeof(Char))

system\globalization\cultureinfo.cs (1)

676if (Char.IsLetterOrDigit(c) || c=='-' || c=='_') {

system\globalization\datetimeformatinfo.cs (7)

2777bool isLetter = Char.IsLetter(ch); 2779ch = Char.ToLower(ch, this.Culture); 2820if (Char.IsLetter(nextCh)) { 2872if (temp != null && Char.ToLower(temp.tokenString[0], this.Culture) != ch) { 2896if (Char.IsWhiteSpace(str[0]) || Char.IsWhiteSpace(str[str.Length - 1])) { 2902char ch = Char.ToLower(str[0], this.Culture);

system\globalization\datetimeformatinfoscanner.cs (4)

192if (Char.IsLetter(ch) || ch == '\'' || ch == '.') 316} else if (Char.IsWhiteSpace(ch)) 480if (m_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !Char.IsWhiteSpace(ch)) 676if ( Char.IsWhiteSpace(array[i][j]) )

system\globalization\datetimeparse.cs (21)

system\globalization\idnmapping.cs (8)

607if (Char.IsLowSurrogate(unicode, iTest)) 627Contract.Assert(Char.IsLowSurrogate(unicode, basicCount) == false, 657else if (Char.IsSurrogatePair(unicode, basicCount)) 704test = Char.ConvertToUtf32(unicode, j); 717test = Char.ConvertToUtf32(unicode, j); 992String strTemp = Char.ConvertFromUtf32(n); 1007if (Char.IsSurrogate(output[iUseInsertLocation])) 1043if (Char.IsLowSurrogate(output.ToString(), iTest)) continue;

system\globalization\textinfo.cs (8)

566static private Char ToLowerAsciiInvariant(Char c) 570c = (Char)(c | 0x20); 603static private Char ToUpperAsciiInvariant(Char c) 607c = (Char)(c & ~0x20); 612static private bool IsAscii(Char c) 729if (Char.CheckLetter(charType)) {

system\guid.cs (3)

621char upperCaseCh = Char.ToUpper(ch, CultureInfo.InvariantCulture); 872if(!Char.IsWhiteSpace(curChar)) 884if(str.Length > i+1 && str[i] == '0' && (Char.ToLower(str[i+1], CultureInfo.InvariantCulture) == 'x'))

system\internal.cs (5)

64new Dictionary<Char, Object>(); 75new Dictionary<Object, Char>(); 98NullableHelper<Char>(); 112new List<Char>(); 131new KeyValuePair<Char, UInt16>('\0', UInt16.MinValue);

system\io\binaryreader.cs (1)

489return EmptyArray<Char>.Value;

system\io\binarywriter.cs (1)

192if (Char.IsSurrogate(ch))

system\io\isolatedstorage\isolatedstorage.cs (2)

325if (!Char.IsLetter(s[i]) && !Char.IsDigit(s[i]))

system\io\path.cs (94)

77public static readonly char[] InvalidPathChars = { '\"', '<', '>', '|', '\0', (Char)1, (Char)2, (Char)3, (Char)4, (Char)5, (Char)6, (Char)7, (Char)8, (Char)9, (Char)10, (Char)11, (Char)12, (Char)13, (Char)14, (Char)15, (Char)16, (Char)17, (Char)18, (Char)19, (Char)20, (Char)21, (Char)22, (Char)23, (Char)24, (Char)25, (Char)26, (Char)27, (Char)28, (Char)29, (Char)30, (Char)31 }; 86private static readonly char[] InvalidPathCharsWithAdditionalChecks = { '\"', '<', '>', '|', '\0', (Char)1, (Char)2, (Char)3, (Char)4, (Char)5, (Char)6, (Char)7, (Char)8, (Char)9, (Char)10, (Char)11, (Char)12, (Char)13, (Char)14, (Char)15, (Char)16, (Char)17, (Char)18, (Char)19, (Char)20, (Char)21, (Char)22, (Char)23, (Char)24, (Char)25, (Char)26, (Char)27, (Char)28, (Char)29, (Char)30, (Char)31, '*', '?' }; 88private static readonly char[] InvalidFileNameChars = { '\"', '<', '>', '|', '\0', (Char)1, (Char)2, (Char)3, (Char)4, (Char)5, (Char)6, (Char)7, (Char)8, (Char)9, (Char)10, (Char)11, (Char)12, (Char)13, (Char)14, (Char)15, (Char)16, (Char)17, (Char)18, (Char)19, (Char)20, (Char)21, (Char)22, (Char)23, (Char)24, (Char)25, (Char)26, (Char)27, (Char)28, (Char)29, (Char)30, (Char)31, ':', '*', '?', '\\', '/' }; 1304private static readonly Char[] s_Base32Char = {

system\io\streamreader.cs (1)

1164private Char[] CharBuffer_Prop {

system\io\streamwriter.cs (10)

473private static async Task WriteAsyncInternal(StreamWriter _this, Char value, 474Char[] charBuffer, Int32 charPos, Int32 charLen, Char[] coreNewLine, 543Char[] charBuffer, Int32 charPos, Int32 charLen, Char[] coreNewLine, 631private static async Task WriteAsyncInternal(StreamWriter _this, Char[] buffer, Int32 index, Int32 count, 632Char[] charBuffer, Int32 charPos, Int32 charLen, Char[] coreNewLine, 821Char[] sCharBuffer, Int32 sCharPos) { 838Char[] charBuffer, Int32 charPos, bool haveWrittenPreamble,

system\number.cs (4)

367public Char * digits; 375this.digits = (((Char*) stackBuffer) + 6); 412Char* p = number.digits; 457Char* p = number.digits;

system\resources\resourcemanager.cs (1)

950while(Char.IsWhiteSpace(asmTypeName1[++comma]));

system\resources\resourcewriter.cs (1)

537else if (type == typeof(Char))

system\runtime\compilerservices\AsyncMethodBuilder.cs (3)

777(typeof(TResult) == typeof(Char) && default(Char) == (Char)(object)result) ||

system\runtime\remoting\message.cs (1)

771else if (pt == typeof(Char))

system\runtime\remoting\remotingconfigparser.cs (1)

1819if (!Char.IsDigit(lastChar))

system\runtime\remoting\soapinteroptypes.cs (14)

93index = value.IndexOf(Char.MinValue); 98stringBuffer.Replace(Char.MinValue.ToString(), "", index, stringBuffer.Length - index); 311Char[] c = value.ToCharArray(); 954Char[] cA = value.ToCharArray(); 971private static Byte ToByte(Char c, String value) 1613Char[] validateChar = {(Char)0xD, (Char)0xA, (Char)0x9}; 1671Char[] validateChar = {(Char)0xD, (Char)0x9}; 1680if (Char.IsWhiteSpace(value[0]) || Char.IsWhiteSpace(value[value.Length - 1]))

system\runtime\serialization\formatter.cs (1)

143} else if (varType==typeof(Char)) {

system\runtime\serialization\formatters\binary\binaryconverter.cs (3)

289array = new Char[length]; 494internal static Type typeofChar = typeof(Char); 519internal static Type typeofCharArray = typeof(Char[]);

system\runtime\serialization\formatters\binary\binaryformatterwriter.cs (2)

87internal void WriteChar(Char value) 92internal void WriteChars(Char[] value)

system\runtime\serialization\formatters\binary\binaryparser.cs (2)

305internal Char ReadChar() 310internal Char[] ReadChars(int length)

system\runtime\serialization\formatters\binary\binaryutilclasses.cs (4)

838Char[] charA = null; 864charA = (Char[])array; 905charA[index] = Char.MinValue; 907charA[index] = Char.Parse(value);

system\security\cryptography\base64transforms.cs (2)

234if (Char.IsWhiteSpace((char)inputBuffer[inputOffset + i])) iCount++; 238if (!Char.IsWhiteSpace((char)inputBuffer[inputOffset + i])) {

system\security\cryptography\utils.cs (2)

633if (Char.IsWhiteSpace(inputBuffer[inputOffset + i])) iCount++; 637if (!Char.IsWhiteSpace(inputBuffer[inputOffset + i]))

system\security\util\hex.cs (1)

64public static int ConvertHexDigit(Char val)

system\string.cs (4)

802if(!Char.IsWhiteSpace(value[i])) return false; 1197if (Char.IsWhiteSpace(pwzChars[i])) { 2754if (!Char.IsWhiteSpace(this[start]) && !IsBOMWhitespace(this[start])) break; 2760if (!Char.IsWhiteSpace(this[end]) && !IsBOMWhitespace(this[start])) break;

system\text\asciiencoding.cs (3)

425Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver), 481Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[ASCIIEncoding.GetByteCount]leftover character should be high surrogate"); 581Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),

system\text\dbcscodepageencoding.cs (2)

572Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[DBCSCodePageEncoding.GetByteCount]leftover character should be high surrogate"); 658Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),

system\text\decoderfallback.cs (4)

169if (Char.IsSurrogate(ch)) 171if (Char.IsHighSurrogate(ch)) 230if (Char.IsSurrogate(ch)) 232if (Char.IsHighSurrogate(ch))

system\text\decoderreplacementfallback.cs (2)

35if (Char.IsSurrogate(replacement,i)) 38if (Char.IsHighSurrogate(replacement, i))

system\text\encoderbestfitfallback.cs (2)

121if (!Char.IsHighSurrogate(charUnknownHigh)) 126if (!Char.IsLowSurrogate(charUnknownLow))

system\text\encoderexceptionfallback.cs (5)

65if (!Char.IsHighSurrogate(charUnknownHigh)) 71if (!Char.IsLowSurrogate(charUnknownLow)) 79int iTemp = Char.ConvertToUtf32(charUnknownHigh, charUnknownLow); 148if (!Char.IsHighSurrogate(charUnknownHigh)) 154if (!Char.IsLowSurrogate(charUnknownLow))

system\text\encoderfallback.cs (3)

178if (Char.IsHighSurrogate(ch)) 201if (Char.IsLowSurrogate(cNext)) 205ThrowLastCharRecursive(Char.ConvertToUtf32(ch, cNext));

system\text\encoderreplacementfallback.cs (6)

37if (Char.IsSurrogate(replacement,i)) 40if (Char.IsHighSurrogate(replacement, i)) 135ThrowLastCharRecursive(Char.ConvertToUtf32(charUnknown, strDefault[fallbackIndex+1])); 152if (!Char.IsHighSurrogate(charUnknownHigh)) 157if (!Char.IsLowSurrogate(charUnknownLow)) 166ThrowLastCharRecursive(Char.ConvertToUtf32(charUnknownHigh, charUnknownLow));

system\text\encoding.cs (4)

1584return EmptyArray<Char>.Value; 1590return EmptyArray<Char>.Value; 1670this.charLeftOver = (Char) info.GetValue("charLeftOver", typeof(Char));

system\text\gb18030encoding.cs (4)

299Contract.Assert(Char.IsHighSurrogate(charLeftOver), 303if (!Char.IsLowSurrogate(ch)) 350else if (Char.IsHighSurrogate(ch)) 355else if (Char.IsLowSurrogate(ch))

system\text\iso2022encoding.cs (3)

434Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[ISO2022Encoding.GetBytesCP5022xJP]leftover character should be high surrogate"); 677Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[ISO2022Encoding.GetBytesCP50225KR]leftover character should be high surrogate"); 825Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[ISO2022Encoding.GetBytesCP52936]leftover character should be high surrogate");

system\text\latin1encoding.cs (2)

82Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver), 200Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),

system\text\sbcscodepageencoding.cs (2)

323Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver), 447Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),

system\text\utf32encoding.cs (6)

487if (Char.IsLowSurrogate(ch)) 516if (Char.IsHighSurrogate(ch)) 526if (Char.IsLowSurrogate(ch)) 617if (Char.IsLowSurrogate(ch)) 679if (Char.IsHighSurrogate(ch)) 689if (Char.IsLowSurrogate(ch))

system\variant.cs (1)

94typeof(Char),

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

115uc = Char.GetUnicodeCategory(name[i]);

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

221else if (typeof(Char).IsAssignableFrom(type))

BuildTasks\Microsoft\Build\Tasks\Windows\UidManager.cs (1)

1105while (!Char.IsWhiteSpace(ch)

BuildTasks\Ms\Internal\MarkupCompiler\MarkupCompiler.cs (2)

1458_typeArgsList = typeArgs.Split(new Char[] { COMMA }); 1566string[] dirs = relPath.Split(new Char[] { ESCAPED_BACKSLASH_CHAR });

Core\CSharp\System\Windows\Media\ParsersCommon.cs (3)

131while ((curIndex < pathString.Length) && Char.IsWhiteSpace(pathString, curIndex)) 145while ((curIndex < pathString.Length) && Char.IsWhiteSpace(pathString, curIndex)) 252if (((ch >' ') && (ch <= 'z')) || ! Char.IsWhiteSpace(ch))

Framework\MS\Internal\Globalization\LocalizationComments.cs (3)

106if (Char.IsWhiteSpace(input[i]) && !escaped) 157else if (!Char.IsWhiteSpace(input[i])) 229if (Char.IsWhiteSpace(input[i]))

Framework\System\Windows\Markup\BamlRecords.cs (1)

2607string [] enumValues = Value.Split(new Char[] { ',' });

Framework\System\Windows\Markup\KnownTypes.cs (1)

5501case KnownElements.Char: t = typeof(Char); break;

Framework\System\Windows\Markup\MarkupExtensionParser.cs (12)

378if (Char.IsWhiteSpace(attrValue[i])) 805(list.Count > 1 && !(list[1] is String) && ((Char)list[1] == ',')))) 881(list.Count > 1 && !(list[1] is String) && ((Char)list[1] == ',')))) 961Char quoteChar = '\''; 990if (!nonWhitespaceFound && !Char.IsWhiteSpace(args[i])) 1120else if (list[list.Count - 1] is Char) 1154else if (list.Count > 0 && (list[list.Count-1] is Char)) 1206Debug.Assert(!Char.IsWhiteSpace(sb[0])); 1209while(Char.IsWhiteSpace(sb[i])) 1275list[listIndex+1] is Char && 1276(Char)list[listIndex+1] == '=') 1371((Char)list[k+1]) != '=')

Framework\System\Windows\Markup\XamlReaderHelper.cs (2)

2554if (Char.IsLetter(i)) 2556else if (Char.IsDigit(i))

Framework\System\Windows\Markup\XamlTypeMapper.cs (4)

818if (!Char.IsWhiteSpace(attribValue[i])) 827else if (Char.IsDigit(attribValue[i])) 3846(Char.IsWhiteSpace(keyString[0]) || 3847Char.IsWhiteSpace(keyString[keyString.Length-1])))

Shared\MS\Internal\TokenizerHelper.cs (5)

105if (!Char.IsWhiteSpace(_str, _charIndex)) 201Debug.Assert(!Char.IsWhiteSpace(currentChar),"Token started on Whitespace"); 242else if ((Char.IsWhiteSpace(currentChar)) || (currentChar == separator)) 288!Char.IsWhiteSpace(currentChar)) 312else if (Char.IsWhiteSpace(currentChar))

Shared\System\Windows\Markup\ReflectionHelper.cs (1)

50string[] nameFrags = typeName.Split(new Char[] { ',' }, 2);

Core\CSharp\MS\Internal\AnimatedTypeHelpers.cs (3)

371internal static Double GetSegmentLengthChar(Char from, Char to) 615internal static bool IsValidAnimationValueChar(Char value)

Core\CSharp\MS\Internal\FontCache\FontCacheUtil.cs (2)

902char ca = Char.ToUpperInvariant(a); 903char cb = Char.ToUpperInvariant(b);

Core\CSharp\System\Windows\Input\TextComposition.cs (1)

342Debug.Assert((_resultText.Length == 1) && Char.IsControl(_resultText[0]));

Core\CSharp\System\Windows\Input\TextCompositionManager.cs (3)

649Char[] chars = new Char[1]; 650chars[0] = (Char) _altNumpadEntry;

Core\CSharp\System\Windows\Interop\HwndKeyboardInputProvider.cs (1)

627Char.IsControl(charcode))

Core\CSharp\System\Windows\Markup\XamlSerializerUtil.cs (1)

56if (!Char.IsWhiteSpace(s[i]))

Core\CSharp\System\Windows\Media\Animation\Generated\CharAnimationBase.cs (9)

103return GetCurrentValue((Char)defaultOriginValue, (Char)defaultDestinationValue, animationClock); 115return typeof(Char); 152public Char GetCurrentValue(Char defaultOriginValue, Char defaultDestinationValue, AnimationClock animationClock) 215protected abstract Char GetCurrentValueCore(Char defaultOriginValue, Char defaultDestinationValue, AnimationClock animationClock);

Core\CSharp\System\Windows\Media\Animation\Generated\CharAnimationUsingKeyFrames.cs (8)

331protected sealed override Char GetCurrentValueCore( 332Char defaultOriginValue, 333Char defaultDestinationValue, 359Char currentIterationValue; 395Char fromValue; 551private Char GetResolvedKeyFrameValue(Int32 resolvedKeyFrameIndex) 862Char prevKeyValue = _keyFrames[index - 1].Value; 866Char currentKeyValue = _keyFrames[index].Value;

Core\CSharp\System\Windows\Media\Animation\Generated\DiscreteKeyFrames.cs (4)

204public DiscreteCharKeyFrame(Char value) 212public DiscreteCharKeyFrame(Char value, KeyTime keyTime) 240protected override Char InterpolateValueCore(Char baseValue, double keyFrameProgress)

Core\CSharp\System\Windows\Media\Animation\Generated\KeyFrames.cs (10)

336protected CharKeyFrame(Char value) 345protected CharKeyFrame(Char value, KeyTime keyTime) 388typeof(Char), 403Value = (Char)value; 410public Char Value 414return (Char)GetValue(ValueProperty); 431public Char InterpolateValue( 432Char baseValue, 452protected abstract Char InterpolateValueCore( 453Char baseValue,

Core\CSharp\System\Windows\Media\Parsers.cs (2)

110string[] preSplit = tokens.Split(new Char[] { ' ' }); 119string[] split = tokens.Split(new Char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

Core\CSharp\System\Windows\Media\ParsersCommon.cs (3)

131while ((curIndex < pathString.Length) && Char.IsWhiteSpace(pathString, curIndex)) 145while ((curIndex < pathString.Length) && Char.IsWhiteSpace(pathString, curIndex)) 252if (((ch >' ') && (ch <= 'z')) || ! Char.IsWhiteSpace(ch))

Core\CSharp\System\Windows\Media3D\ModelVisual3D.cs (1)

114if (!Char.IsWhiteSpace(c))

Core\CSharp\System\Windows\Navigation\BaseUriHelper.cs (1)

359string[] assemblyInfo = component.Split(new Char[] { COMPONENT_DELIMITER });

Core\CSharp\system\windows\TextDecorationCollectionConverter.cs (2)

215&& pattern[i] == Char.ToUpperInvariant(input[index + i]); 262for (; index < input.Length && Char.IsWhiteSpace(input[index]); index++) ;

src\Framework\MS\Internal\Annotations\Anchoring\LocatorManager.cs (2)

1399private static readonly Char[] Separators = new Char[] { ',', ' ', ';' };

src\Framework\MS\Internal\Annotations\Anchoring\TextSelectionProcessor.cs (2)

434internal static readonly Char[] Separator = new Char[] { ',' };

src\Framework\MS\Internal\AppModel\RootBrowserWindow.cs (1)

735if (Char.IsWhiteSpace(rawString[i]) == false)

src\Framework\MS\Internal\Data\DefaultValueConverter.cs (2)

490if (sourceType == typeof(Char)) 492if (targetType == typeof(Char))

src\Framework\MS\Internal\Data\PathParser.cs (5)

106if (Char.IsWhiteSpace(c)) 259Char c = _path[_index++]; 282else if (Char.IsWhiteSpace(c)) 330else if (Char.IsWhiteSpace(c)) 397const char NullChar = Char.MinValue;

src\Framework\MS\Internal\Data\PropertyPathWorker.cs (4)

1899static readonly Char[] s_comma = new Char[]{','}; 1900static readonly Char[] s_dot = new Char[]{'.'};

src\Framework\MS\Internal\Data\XmlBindingWorker.cs (2)

582if (! (Char.IsLetter(c) || c == '_' || c == ':') ) 591if (! (Char.IsLetterOrDigit(c) || c == '.' || c == '-' || c == '_' || c == ':') )

src\Framework\MS\Internal\Globalization\LocalizationComments.cs (3)

106if (Char.IsWhiteSpace(input[i]) && !escaped) 157else if (!Char.IsWhiteSpace(input[i])) 229if (Char.IsWhiteSpace(input[i]))

src\Framework\System\Windows\Application.cs (2)

2692string[] bamlConvertUriSegments = fileInBamlConvert.Split(new Char[] { '/', '\\' }); 2693string[] curUriSegments = fileCurrent.Split(new Char[] { '/', '\\' });

src\Framework\System\Windows\Controls\DefinitionBase.cs (2)

565bool isDigit = Char.IsDigit(id[i]); 569|| Char.IsLetter(id[i])

src\Framework\System\Windows\Documents\DocumentSequence.cs (1)

182if (Char.IsDigit(elementID[0]))

src\Framework\System\Windows\Documents\FixedDocument.cs (1)

225if (Char.IsDigit(elementID[0]))

src\Framework\System\Windows\Documents\FixedSOMTextRun.cs (1)

180if (!Char.IsWhiteSpace(s[i]))

src\Framework\System\Windows\Documents\Glyphs.cs (3)

265if (Char.IsWhiteSpace(c)) 403if (!Char.IsWhiteSpace(c)) 434if (!Char.IsWhiteSpace(valueSpec[i]))

src\Framework\System\Windows\Documents\Speller.cs (1)

260Char[] charArray = null;

src\Framework\System\windows\Documents\TextEditor.cs (5)

1238if (textData.Length == extraCharsAllowed && Char.IsHighSurrogate(textData, extraCharsAllowed - 1)) 1243if (!string.IsNullOrEmpty(textData) && Char.IsLowSurrogate(textData, 0)) 1246if (string.IsNullOrEmpty(textAdjacent) || !Char.IsHighSurrogate(textAdjacent, textAdjacent.Length - 1)) 1494(Char.IsHighSurrogate(text, position - 1) && Char.IsLowSurrogate(text, position)))

src\Framework\System\windows\Documents\TextEditorSpelling.cs (2)

73else if (Char.IsWhiteSpace(character)) 324if (!Char.IsWhiteSpace(character))

src\Framework\System\windows\Documents\TextEditorTyping.cs (1)

1556if (Char.IsControl(textData[i]))

src\Framework\System\Windows\Documents\TextFindEngine.cs (4)

891if (Char.IsWhiteSpace(separatorChar) || 892Char.IsPunctuation(separatorChar) || 893Char.IsSymbol(separatorChar) || 894Char.IsSeparator(separatorChar))

src\Framework\System\Windows\Documents\TextPointerBase.cs (5)

642internal static Char[] NextLineCharacters = new char[] { '\n', '\r', '\v', '\f', '\u0085' /*NEL*/, '\u2028' /*LS*/, '\u2029' /*PS*/ }; 1370Char[] neighborhood = new char[2]; 1375if (Char.IsSurrogatePair(neighborhood[0], neighborhood[1]) || 1391UnicodeCategory category1 = Char.GetUnicodeCategory(neighborhood[1]); 1396UnicodeCategory category0 = Char.GetUnicodeCategory(neighborhood[0]);

src\Framework\System\Windows\Documents\TextRangeBase.cs (7)

666Char[] charArray = null; // used for extracting text runs 676internal static string GetTextInternal(ITextPointer startPosition, ITextPointer endPosition, ref Char[] charArray) 759private static void PlainConvertTextRun(StringBuilder textBuffer, ITextPointer navigator, ITextPointer endPosition, ref Char[] charArray) 882private static Char[] EnsureCharArraySize(Char[] charArray, int textLength) 896charArray = new Char[newLength]; 905Char[] charArray = null;

src\Framework\System\Windows\Documents\TextRangeSerialization.cs (6)

316char[] text = new Char[textLength]; 1803if (Char.IsHighSurrogate(testChar) || Char.IsLowSurrogate(testChar) || IsBadCode(testChar)) 1820if (Char.IsHighSurrogate(text[i])) 1822if (i + 1 < length && Char.IsLowSurrogate(text[i + 1])) 1836else if (Char.IsLowSurrogate(text[i]))

src\Framework\System\windows\Documents\TextSelection.cs (3)

508Char.IsWhiteSpace(charBuffer[0])) 521!Char.IsWhiteSpace(charBuffer[0]))) 2507fontSignature = new String(new Char[FONTSIGNATURE_SIZE]);

src\Framework\System\Windows\Documents\TextStore.cs (2)

1369Char[] nextChars; 1370nextChars = new Char[2];

src\Framework\System\Windows\Markup\Baml2006\Baml2006KnownTypes.cs (1)

159case 67: t = () => typeof(Char); break;

src\Framework\System\Windows\Markup\Baml2006\Baml2006Reader.cs (1)

1035if (!Char.IsWhiteSpace(value[i]))

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

2454typeof(System.Char),

src\Framework\System\Windows\Markup\BamlRecords.cs (1)

2607string [] enumValues = Value.Split(new Char[] { ',' });

src\Framework\System\Windows\Markup\KnownTypes.cs (1)

5611case KnownElements.Char: t = typeof(System.Char); break;

src\Framework\System\Windows\Markup\MarkupExtensionParser.cs (12)

378if (Char.IsWhiteSpace(attrValue[i])) 805(list.Count > 1 && !(list[1] is String) && ((Char)list[1] == ',')))) 881(list.Count > 1 && !(list[1] is String) && ((Char)list[1] == ',')))) 961Char quoteChar = '\''; 990if (!nonWhitespaceFound && !Char.IsWhiteSpace(args[i])) 1120else if (list[list.Count - 1] is Char) 1154else if (list.Count > 0 && (list[list.Count-1] is Char)) 1206Debug.Assert(!Char.IsWhiteSpace(sb[0])); 1209while(Char.IsWhiteSpace(sb[i])) 1275list[listIndex+1] is Char && 1276(Char)list[listIndex+1] == '=') 1371((Char)list[k+1]) != '=')

src\Framework\System\Windows\Markup\XamlSerializerUtil.cs (1)

55if (!Char.IsWhiteSpace(s[i]))

src\Framework\System\Windows\Markup\XamlTypeMapper.cs (4)

818if (!Char.IsWhiteSpace(attribValue[i])) 827else if (Char.IsDigit(attribValue[i])) 3846(Char.IsWhiteSpace(keyString[0]) || 3847Char.IsWhiteSpace(keyString[keyString.Length-1])))

src\Framework\System\Windows\PropertyPath.cs (2)

974static readonly Char[] s_comma = new Char[]{','};

System\ServiceModel\Diagnostics\PlainXmlWriter.cs (2)

180public override void WriteChars(Char[] buffer, int index, int count) 207public override void WriteRaw(Char[] buffer, int index, int count)

compmod\microsoft\csharp\csharpcodeprovider.cs (3)

466if( Char.IsHighSurrogate(value[i]) 468&& Char.IsLowSurrogate(value[i+1])){ 1297if(Char.IsSurrogate(c)) {

compmod\microsoft\visualbasic\VBCodeProvider.cs (2)

482if( Char.IsHighSurrogate(value[i]) 484&& Char.IsLowSurrogate(value[i+1])){

compmod\system\codedom\CodeTypeReference.cs (2)

386while( start < typeName.Length && Char.IsWhiteSpace(typeName[start])) start++; 387while( end >= 0 && Char.IsWhiteSpace(typeName[end])) end--;

compmod\system\codedom\compiler\CodeGenerator.cs (1)

1936UnicodeCategory uc = Char.GetUnicodeCategory(ch);

compmod\system\componentmodel\MaskedTextProvider.cs (7)

2204if (Char.IsLetter(input)) 2206if (Char.IsUpper(input)) 2383if (!Char.IsDigit(input) && (input != '-') && (input != '+') && input != spaceChar) 2391if (!Char.IsDigit(input)) 2399if (!Char.IsDigit(input) && input != spaceChar) 2407if (!Char.IsLetter(input)) 2420if (!Char.IsLetter(input) && input != spaceChar)

net\System\_UncName.cs (2)

74if (Char.IsLetter(name[i]) || name[i] == '-' || name[i] == '_') 108else if (Char.IsLetter(name[i]) || (name[i] >= '0' && name[i] <= '9'))

net\System\IriHelper.cs (3)

30Debug.Assert(Char.IsHighSurrogate(highSurr)); 32if (Char.IsSurrogatePair(highSurr, lowSurr)) 273if ((Char.IsHighSurrogate(ch)) && (next + 1 < end))

net\System\Net\_Connection.cs (3)

1725if (Char.IsDigit((char)statusLine[bytesParsed])) { 1741else if (!Char.IsWhiteSpace((char) statusLine[bytesParsed])) { 2684while(i < server.Length && Char.IsDigit(server[i])) {

net\System\Net\_FtpControlStream.cs (4)

1056if (!Char.IsNumber(parsedList[index], 0)) 1186if(!(Char.IsDigit(responseString[0]) && Char.IsDigit(responseString[1]) && Char.IsDigit(responseString[2]) && (responseString[3] == ' ' || responseString[3] == '-'))) {

net\System\Net\_HTTPDateParse.cs (1)

85return(Char.ToUpper(c, CultureInfo.InvariantCulture));

net\System\Net\cookie.cs (1)

1036while ((m_index < m_length) && Char.IsWhiteSpace(m_tokenStream[m_index])) {

net\System\Net\HttpListenerRequest.cs (4)

1235if ((chPrev == ';' || chPrev == ',' || Char.IsWhiteSpace(chPrev)) && (chNext == '=' || Char.IsWhiteSpace(chNext))) 1246while (i < l && Char.IsWhiteSpace(headerValue[i])) 1251while (i < l && Char.IsWhiteSpace(headerValue[i]))

net\System\Net\mail\SmtpDateTime.cs (1)

271if (!Char.IsLetter(value, i))

net\System\Net\SocketPermission.cs (1)

837else if (!Char.IsDigit(hostname[i])) { // Not a digit?

net\System\Net\WebUtility.cs (5)

123if (encodeConformance == UnicodeEncodingConformance.Strict && Char.IsSurrogate(ch)) { 297else if (encodeConformance == UnicodeEncodingConformance.Strict && Char.IsSurrogate(ch)) { 618Debug.Assert(Char.IsSurrogate(*pch)); 628if (Char.IsSurrogatePair(leadingSurrogate, trailingSurrogate)) { 710if (c == '&' || Char.IsSurrogate(c)) {

net\System\URI.cs (3)

4474if (Char.IsHighSurrogate(c)){ 5210|| (Char.ToLower(path1[i], CultureInfo.InvariantCulture) 5211!= Char.ToLower(path2[i], CultureInfo.InvariantCulture))))

net\System\UriHelper.cs (3)

87if (Char.ToLower(chMe, CultureInfo.InvariantCulture) != Char.ToLower(chShe, CultureInfo.InvariantCulture)) 514bool isHighSurr = Char.IsHighSurrogate(unescapedCharsPtr[j]);

regex\system\text\regularexpressions\RegexBoyerMoore.cs (3)

62sb.Append(Char.ToLower(pattern[i], culture)); 315chTest = Char.ToLower(chTest, _culture); 341chTest = Char.ToLower(chTest, _culture);

regex\system\text\regularexpressions\RegexCharClass.cs (3)

642range._first = range._last = Char.ToLower(range._first, culture); 910if (Char.IsWhiteSpace(ch)) 925if (!Char.IsWhiteSpace(ch))

regex\system\text\regularexpressions\RegexCompiler.cs (2)

165_chartolowerM = typeof(Char).GetMethod("ToLower", new Type[] {typeof(Char), typeof(CultureInfo)});

regex\system\text\regularexpressions\RegexInterpreter.cs (4)

235return(runci ? Char.ToLower(ch, runculture) : ch); 262if (str[--c] != Char.ToLower(runtext[--pos], runculture)) 303if (Char.ToLower(runtext[--cmpos], runculture) != Char.ToLower(runtext[--pos], runculture))

regex\system\text\regularexpressions\RegexParser.cs (5)

1090ch = Char.ToLower(ch, _culture); 1888sb.Append(Char.ToLower(str[i], _culture)); 1898ch = Char.ToLower(ch, _culture); 1997ch = Char.ToLower(ch, _culture); 2007ch = Char.ToLower(ch, _culture);

security\system\security\cryptography\x509\x509utils.cs (3)

236if (Char.IsWhiteSpace(inputBuffer[inputOffset + i])) iCount++; 240if (!Char.IsWhiteSpace(inputBuffer[inputOffset + i])) { 469if (Char.IsDigit(keyValue[i]))

services\monitoring\system\diagnosticts\EventLog.cs (2)

1247while (i + 1 < formatString.Length && Char.IsDigit(formatString[i + 1])) { 1347UnicodeCategory uc = Char.GetUnicodeCategory(c);

services\monitoring\system\diagnosticts\EventLogEntry.cs (1)

439while ( lasNumIdx < msgLength && Char.IsDigit(msg, lasNumIdx) )

services\monitoring\system\diagnosticts\EventLogInternal.cs (1)

1484UnicodeCategory uc = Char.GetUnicodeCategory(c);

sys\system\runtime\versioning\FrameworkName.cs (3)

20const Char c_componentSeparator = ','; 21const Char c_keyValueSeparator = '='; 22const Char c_versionValuePrefix = 'v';

System\Addin\MiniReflection\MiniParameterInfo.cs (1)

91return new TypeInfo(typeof(Char));

System\Addin\Contract\RemoteArgument.cs (5)

415public RemoteArgument(System.Char value) 423public RemoteArgument(System.Char value, bool isByRef) 901public System.Char CharValue 909return default(System.Char); 915return (System.Char)this._value;

DataAnnotations\PhoneAttribute.cs (4)

41if (Char.IsDigit(c)) { 53if (!(Char.IsDigit(c) 54|| Char.IsWhiteSpace(c) 128if (!Char.IsDigit(c)) {

System\Configuration\ClientConfigPaths.cs (1)

41static Char[] s_Base32Char = {

System\Configuration\GenericEnumConverter.cs (1)

51(Char.IsDigit(value[0]) ||

Microsoft\Scripting\Ast\DebugViewWriter.cs (1)

1157if (Char.IsWhiteSpace(c)) {

Microsoft\Scripting\Ast\ParameterExpression.cs (1)

51case TypeCode.Char: return new PrimitiveParameterExpression<Char>(name);

fx\src\data\Microsoft\SqlServer\Server\ITypedGetters.cs (1)

31Char GetChar( int ordinal );

fx\src\data\Microsoft\SqlServer\Server\MetadataUtilsSmi.cs (2)

95ht.Add( typeof( System.Char ), ExtendedClrTypeCode.Char ); 112ht.Add( typeof( System.Char[] ), ExtendedClrTypeCode.CharArray );

fx\src\data\Microsoft\SqlServer\Server\SmiRecordBuffer.cs (1)

142public virtual Char GetChar( int ordinal ) {

fx\src\data\Microsoft\SqlServer\Server\SmiRequestExecutor.cs (1)

200public virtual Char GetChar( int ordinal ) {

fx\src\data\System\Data\CodeGen\datacache.cs (1)

50unc = Char.GetUnicodeCategory(ret[i]);

fx\src\data\System\Data\ColumnTypeConverter.cs (1)

28typeof(Char),

fx\src\data\System\Data\Common\AdapterUtil.cs (2)

2011int h = hexDigits.IndexOf(Char.ToLower(c[i], invariant)); 2012int l = hexDigits.IndexOf(Char.ToLower(c[i+1], invariant));

fx\src\data\System\Data\Common\CharStorage.cs (21)

18private const Char defaultValue = '\0'; 20private Char[] values; 23: base(column, typeof(Char), defaultValue, StorageType.Char) { 31Char min = Char.MaxValue; 45Char max = Char.MinValue; 70throw ExprException.Overflow(typeof(Char)); 76Char valueNo1 = values[recordNo1]; 77Char valueNo2 = values[recordNo2]; 99Char valueNo1 = values[recordNo]; 103return valueNo1.CompareTo((Char)value); 125Char value = values[record]; 139Char ch = ((IConvertible)value).ToChar(FormatProvider); 149Char[] newValues = new Char[capacity]; 162return XmlConvert.ToString((Char) value); 166return new Char[recordCount]; 170Char[] typedStore = (Char[]) store; 176values = (Char[]) store;

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

75typeof(Char),

fx\src\data\System\Data\Common\DbConnectionOptions.cs (14)

563while ((0 < count) && Char.IsWhiteSpace(buffer[count-1])) { 573while ((index < count) && Char.IsWhiteSpace(buffer[index])) { 576while ((0 < count) && Char.IsWhiteSpace(buffer[count-1])) { 616if ((';' == currentChar) || Char.IsWhiteSpace(currentChar)) { 620if (Char.IsControl(currentChar)) { throw ADP.ConnectionStringSyntax(startposition); } 633if (Char.IsWhiteSpace(currentChar)) { break; } 634if (Char.IsControl(currentChar)) { throw ADP.ConnectionStringSyntax(startposition); } 646if (Char.IsWhiteSpace(currentChar)) { continue; } 656if (Char.IsControl(currentChar)) { throw ADP.ConnectionStringSyntax(startposition); } 661if (Char.IsWhiteSpace(currentChar)) { break; } 662if (Char.IsControl(currentChar) || ';' == currentChar) { goto ParserExit; } 699if (Char.IsWhiteSpace(currentChar)) { continue; } 706if (Char.IsWhiteSpace(currentChar)) { continue; } // MDAC 83540 780return ((0 < keyname.Length) && (';' != keyname[0]) && !Char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000')));

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

59return Char.IsWhiteSpace (ch);

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

220else if (valType == typeof(Char)){ 221values[recordNo] = BitConverter.GetBytes((Char)value);

fx\src\data\System\Data\Common\SQLConvert.cs (2)

498return ((IConvertible)(Char)value).ToString(formatProvider); 745return XmlConvert.ToString((Char) value);

fx\src\data\System\Data\DataColumn.cs (2)

581if (value == typeof(Char)) 1321if (this.dataType == typeof(Char))

fx\src\data\System\Data\Odbc\Odbc32.cs (1)

906else if (dataType == typeof(System.Char[])) {

fx\src\data\System\Data\Odbc\OdbcDataReader.cs (4)

603override public Char GetChar(int i) { 604return (Char)internalGetChar(i); 839Char[] rgChars = new Char[cbMaxData / 2];

fx\src\data\System\Data\Odbc\OdbcParameter.cs (1)

618if (value is Char) {

fx\src\data\System\Data\Odbc\OdbcUtils.cs (5)

166Char[] rgChars; 376while((_idx < _len) && Char.IsWhiteSpace(_sqlstatement[_idx])) { 409if (!Char.IsWhiteSpace(currentchar)) { 469return (Char.IsLetterOrDigit(ch) || 496while((tempidx < _len) && Char.IsWhiteSpace(_sqlstatement[tempidx])) {

fx\src\data\System\Data\OleDb\OLEDB_Util.cs (1)

638if ((0 < builder.Length) && Char.IsDigit(builder[0])) {

fx\src\data\System\Data\OleDb\OleDbDataReader.cs (1)

849override public Char GetChar(int ordinal) {

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

162internal Char ReadChar(int offset) {

fx\src\data\System\Data\SimpleType.cs (1)

359if ((typeCode == StorageType.Char) && (type == typeof(Char))) {

fx\src\data\System\Data\Sql\SqlMetaData.cs (5)

1050case TypeCode.Char: value = this.Adjust((Char)value); break; 1068else if (dataType == typeof(System.Char[])) 1069value = this.Adjust((System.Char[])value); 1176else if (dataType == typeof(System.Char[])) 1178long maxLen = ((System.Char[])value).Length;

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

2638if (Char.IsDigit(sproc[sproc.Length-1])) { // If last char is a digit, parse.

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

1185else if (type == typeof(Char[])) {

fx\src\data\System\Data\SqlClient\SqlEnums.cs (3)

502else if (comVal is System.Char) 504else if (comVal is System.Char[]) 505sqlVal = new SqlChars((System.Char[])comVal);

fx\src\data\System\Data\SQLTypes\SQLBoolean.cs (1)

258if (Char.IsNumber(wchFirst) || ('-' == wchFirst) || ('+' == wchFirst)) {

fx\src\data\System\Data\XDRSchema.cs (1)

220new NameType("char" , typeof(Char) ), /* XDR */

fx\src\data\System\Data\xmlsaver.cs (6)

204if (type == typeof(Char)) 2273if (valuesType == typeof(Type) || valuesType == typeof(Guid)|| valuesType == typeof(Char) || 2644if (valuesType == typeof(Type) || valuesType == typeof(Guid)|| valuesType == typeof(Char) || 2686if (!Char.IsWhiteSpace(tempValue, i)) { 2783public override void WriteChars(Char[] buffer, int index, int count) { 2787public override void WriteRaw(Char[] buffer, int index, int count) {

fx\src\data\System\Data\XMLSchema.cs (2)

1935type = typeof(Char); 2088type = typeof(Char);

System\Data\Common\EntitySql\AST\QueryParameter.cs (1)

35if (_name.StartsWith("_", StringComparison.OrdinalIgnoreCase) || Char.IsDigit(_name, 0))

System\Data\Common\EntitySql\CqlLexerHelpers.cs (12)

91static readonly Char[] _newLineCharacters = { '\u000A' , // LF - line feed 197if (Char.IsWhiteSpace(c) || Char.IsControl(c)) 211if (Char.IsLetter(c) || Char.IsSymbol(c) || Char.IsNumber(c)) 373Char lookAheadChar = GetLookAheadChar(); 415private bool IsCanonicalFunctionCall(string symbol, Char lookAheadChar) 446private Char GetLookAheadChar() 449Char lookAheadChar = yy_advance(); 450while (lookAheadChar != YY_EOF && (Char.IsWhiteSpace(lookAheadChar) || IsNewLine(lookAheadChar))) 676internal static bool IsNewLine(Char c)

System\Data\Common\Internal\MultipartIdentifier.cs (1)

45return Char.IsWhiteSpace(ch);

System\Data\Common\Utils\StringUtil.cs (2)

175if (!Char.IsWhiteSpace(value[i])) 196if (!Char.IsWhiteSpace(value[i]))

System\Data\EntityClient\DbConnectionOptions.cs (14)

160while ((0 < count) && Char.IsWhiteSpace(buffer[count - 1])) 173while ((index < count) && Char.IsWhiteSpace(buffer[index])) 177while ((0 < count) && Char.IsWhiteSpace(buffer[count - 1])) 220if ((';' == currentChar) || Char.IsWhiteSpace(currentChar)) 225if (Char.IsControl(currentChar)) { throw EntityUtil.ConnectionStringSyntax(startposition); } 240if (Char.IsWhiteSpace(currentChar)) { break; } 241if (Char.IsControl(currentChar)) { throw EntityUtil.ConnectionStringSyntax(startposition); } 253if (Char.IsWhiteSpace(currentChar)) { continue; } 259if (Char.IsControl(currentChar)) { throw EntityUtil.ConnectionStringSyntax(startposition); } 264if (Char.IsWhiteSpace(currentChar)) { break; } 265if (Char.IsControl(currentChar) || ';' == currentChar) { goto ParserExit; } 291if (Char.IsWhiteSpace(currentChar)) { continue; } 298if (Char.IsWhiteSpace(currentChar)) { continue; } // MDAC 83540 377return ((0 < keyname.Length) && (';' != keyname[0]) && !Char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000')));

System\Data\EntitySqlException.cs (3)

217Char c = commandText[i]; 222else if ((Char.IsControl(c) || Char.IsWhiteSpace(c)) && ('\r' != c))

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

710if (clrType == typeof(System.Char[]))

System\Data\Objects\ELinq\MethodCallTranslator.cs (3)

1365yield return typeof(String).GetMethod("Trim", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(Char[]) }, null); 1375yield return typeof(String).GetMethod("TrimStart", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(Char[]) }, null); 1385yield return typeof(String).GetMethod("TrimEnd", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(Char[]) }, null);

System\Data\Entity\Design\Common\MetadataUtil.cs (2)

107if (!Char.IsWhiteSpace(value[i])) 128if (!Char.IsWhiteSpace(value[i]))

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

820if ((127 < (int)c) || Char.IsWhiteSpace(c) || Char.IsControl(c))

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

563while (textIndex < text.Length && Char.IsWhiteSpace(text, textIndex))

System\Data\Services\Parsing\ExpressionLexer.cs (11)

116while (Char.IsWhiteSpace(this.ch)) 139if (hasNext && Char.IsDigit(this.text[this.textPos + 1])) 217if (Char.IsLetter(this.ch) || this.ch == '_') 224if (Char.IsDigit(this.ch)) 474Debug.Assert(Char.IsDigit(this.ch), "Char.IsDigit(this.ch)"); 490while (Char.IsDigit(this.ch)) 505while (Char.IsDigit(this.ch)); 522while (Char.IsDigit(this.ch)); 554Debug.Assert(Char.IsLetter(this.ch) || this.ch == '_', "Char.IsLetter(this.ch) || this.ch == '_'"); 559while (Char.IsLetterOrDigit(this.ch) || this.ch == '_'); 573if (!Char.IsDigit(this.ch))

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

99else if (Char.IsDigit(ch) || (ch == '-') || (ch == '.')) 191while ((ch != '\0') && Char.IsWhiteSpace(ch)) 288if ((ch == '_') || Char.IsLetterOrDigit(ch) || ch == '$') 332if (Char.IsDigit(ch) || (ch == '.') || (ch == 'E') || (ch == 'e') || (ch == '-') || (ch == '+'))

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

1155(Char.IsWhiteSpace(elementValue, 0) || 1156Char.IsWhiteSpace(elementValue, elementValue.Length - 1))) 1656if (!Char.IsWhiteSpace(c))

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

563while (textIndex < text.Length && Char.IsWhiteSpace(text, textIndex))

parent\Server\System\Data\Services\Parsing\WebConvert.cs (1)

806if (!Char.IsDigit(c))

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

820if ((127 < (int)c) || Char.IsWhiteSpace(c) || Char.IsControl(c))

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

466types[(int)StorageType.Char] = typeof(Char); 467types[(int)StorageType.CharArray] = typeof(Char[]);

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

2502if (Char.IsWhiteSpace(convertedValue[0]) || 2503Char.IsWhiteSpace(convertedValue[convertedValue.Length - 1]))

System\Data\Common\Utils\StringUtil.cs (2)

36if (!Char.IsWhiteSpace(value[i])) 56if (!Char.IsWhiteSpace(value[i]))

System\Data\EntityModel\DataServiceBuildProvider.cs (2)

246if (i == 0 && Char.IsDigit(typeName[0])) 249if (Char.IsLetterOrDigit(typeName[i]))

commonui\System\Drawing\Advanced\ColorTranslator.cs (3)

245string r = Char.ToString(htmlColor[1]); 246string g = Char.ToString(htmlColor[2]); 247string b = Char.ToString(htmlColor[3]);

commonui\System\Drawing\FontConverter.cs (1)

466if (Char.IsLetter(text[splitPoint])) {

System\IdentityModel\SecurityUtils.cs (1)

585static int ConvertHexDigit(Char val)

Instrumentation\SchemaMapping.cs (2)

400 else if(t2 == typeof(Int16) || t2 == typeof(UInt16) || t2 == typeof(Char)) 540 else if(t2 == typeof(Char))

managementquery.cs (5)

1080 if ((0 == q.Length) || !Char.IsWhiteSpace (q[0])) 1654 if ((0 == q.Length) || !Char.IsWhiteSpace (q[0])) 1690 if ((0 == q.Length) || !Char.IsWhiteSpace (q[0])) 2169 if ((0 == q.Length) || !Char.IsWhiteSpace (q[0])) 2205 if ((0 == q.Length) || !Char.IsWhiteSpace (q[0]))

property.cs (10)

321 val = new Char [length]; 324 ((Char[])val) [i] = (Char)((Int16)(wmiValueArray.GetValue(i))); 364 val = (Char)((Int16)wmiValue); 488 ((Int16[])(wmiValue))[i] = (Int16)Convert.ToChar(valArray.GetValue(i),(IFormatProvider)culInfo.GetFormat(typeof(System.Char))); 579 wmiValue = (Int16)Convert.ToChar(val,(IFormatProvider)culInfo.GetFormat(typeof(System.Char))); 723 else if (elementType == typeof(System.Char)) 731 ((short[])wmiValue) [i] = ((IConvertible)((System.Char)(arrayValue[i]))).ToInt16(null); 825 else if (valueType == typeof(System.Char)) 828 wmiValue = ((IConvertible)((System.Char)val)).ToInt16(null);

WmiGenerator.cs (4)

909if(Char.IsLetter(strClass[0]) == false) 1169if (Char.IsLetterOrDigit(strPropTemp[i]) == true) 4845if (Char.IsLetter(arrString[0]) == false) 4854if (Char.IsLetterOrDigit(arrString[i]) == false)

System\Messaging\ActiveXMessageFormatter.cs (1)

312byte[] bytes = BitConverter.GetBytes((Char)obj);

channels\http\httpstreams.cs (1)

573if (Char.IsLetter((char)b) ||

metadata\sudscommon.cs (1)

78internal static Type typeofChar = typeof(Char);

metadata\wsdlparser.cs (4)

2482UnicodeCategory uc = Char.GetUnicodeCategory(c); 6415Char[] outChar = new Char[value.Length]; 6418if (Char.IsDigit(value[i]))

metadata\wsdlwriter.cs (1)

816private static Type s_charType = typeof(System.Char);

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

1587return (Char.GetUnicodeCategory(c) != UnicodeCategory.DecimalDigitNumber); 1592UnicodeCategory uc = Char.GetUnicodeCategory(c);

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

736type = typeof(Char);

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

1279if (Char.IsHighSurrogate((char)charValue)) 1290if (!Char.IsLowSurrogate(lowChar))

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

86public override void WriteChars(Char[] buffer, int index, int count) { xmlWriter.WriteChars(buffer, index, count); } 87public override void WriteRaw(Char[] buffer, int index, int count) { xmlWriter.WriteRaw(buffer, index, count); }

System\Xml\EncodingStreamWrapper.cs (1)

447if (key[i] != Char.ToLower((char)buffer[offset + i], System.Globalization.CultureInfo.InvariantCulture))

system\security\cryptography\xml\transform.cs (4)

607while ((j < bytesRead) && (!Char.IsWhiteSpace((char) buffer[j]))) j++; 610if (!Char.IsWhiteSpace((char) buffer[j])) { 634while ((j <buffer.Length) && (!Char.IsWhiteSpace((char) buffer[j]))) j++; 637if (!Char.IsWhiteSpace((char) buffer[j])) {

system\security\cryptography\xml\utils.cs (2)

134if (Char.IsWhiteSpace(inputBuffer[inputOffset + i])) iCount++; 138if (!Char.IsWhiteSpace(inputBuffer[inputOffset + i])) {

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

938Char.IsUpper(interfaceName, 1))

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

62return (Char.GetUnicodeCategory(c) != UnicodeCategory.DecimalDigitNumber); 67UnicodeCategory uc = Char.GetUnicodeCategory(c);

System\ServiceModel\MsmqIntegration\ActiveXSerializer.cs (1)

305byte[] bytes = BitConverter.GetBytes((Char)obj);

System\ServiceModel\Security\XmlHelper.cs (3)

313if ((!Char.IsLetter(idPrefix[0]) && idPrefix[0] != '_')) 321if (!Char.IsLetter(c) && !Char.IsNumber(c) && c != '.' && c != '_' && c != '-')

System\Runtime\TypeHelper.cs (2)

513Char charSource = (Char)source;

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

226UnicodeCategory uc = Char.GetUnicodeCategory(c); 251return (Char.GetUnicodeCategory(c) != UnicodeCategory.DecimalDigitNumber);

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

41this.defaultSupportedQueryStringTypes.Add(typeof(Char), null); 107return parameter == null ? default(Char) : XmlConvert.ToChar(parameter);

System\ServiceModel\Web\HttpDateParse.cs (1)

87return (Char.ToUpper(c, CultureInfo.InvariantCulture));

System\Transactions\Trace\PlainXmlWriter.cs (2)

194public override void WriteChars(Char[] buffer, int index, int count) 205public override void WriteRaw(Char[] buffer, int index, int count)

Configuration\BrowserDefinition.cs (3)

55if(Char.IsDigit(s[0])) { 58else if(Char.IsLetter(s[0])) { 64if (Char.IsLetterOrDigit(s[i]) || s[i] == '_') {

Configuration\IISMapPath.cs (1)

52if (!Char.IsDigit(siteName[i])) {

Hosting\ApplicationManager.cs (1)

1330if (!Char.IsWhiteSpace(publicKey[i])) {

HttpRequest.cs (4)

850if ((chPrev == ';' || chPrev == ',' || Char.IsWhiteSpace(chPrev)) && (chNext == '=' || Char.IsWhiteSpace(chNext))) 861while (i < l && Char.IsWhiteSpace(headerValue[i])) 866while (i < l && Char.IsWhiteSpace(headerValue[i]))

Management\EventlogProvider.cs (2)

273if (s[i] == '%' && Char.IsDigit(s[i+1])) { 283if (s[i] == '%' && Char.IsDigit(s[i+1])) {

ModelBinding\ModelBinderUtil.cs (1)

74if (!Char.IsWhiteSpace(s[i])) {

Security\AntiXss\UnicodeCharacterEncoder.cs (1)

258if (currentCodePoint > Char.MaxValue) {

Security\AntiXss\Utf16StringReader.cs (4)

68Debug.Assert(Char.IsHighSurrogate(leadingSurrogate), "'leadingSurrogate' was not a high surrogate."); 69Debug.Assert(Char.IsLowSurrogate(trailingSurrogate), "'trailingSurrogate' was not a low surrogate."); 100if (Char.IsHighSurrogate(thisCodeUnit)) { 103if (Char.IsLowSurrogate(nextCodeUnit)) {

Security\Membership.cs (1)

354while( !Char.IsLetterOrDigit( cBuf[k] ) );

Security\MembershipPasswordAttribute.cs (1)

185int nonAlphanumericCharacters = valueAsString.Count(c => !Char.IsLetterOrDigit(c));

State\SessionStateItemCollection.cs (1)

169t=typeof(Char);

UI\ClientScriptManager.cs (1)

925while ((index >= 0) && Char.IsWhiteSpace(script, index)) {

UI\DataBinder.cs (1)

237if (Char.IsDigit(index[0])) {

UI\HTMLTextWriter.cs (1)

1308Write(HttpUtility.UrlEncodeNonAscii(Char.ToString(ch), Encoding.UTF8));

UI\TemplateParser.cs (2)

2514for (int i = 0; i < code.Length && Char.IsWhiteSpace(code[i]); i++) { 2536for (int i = code.Length - 1; i >= 0 && Char.IsWhiteSpace(code[i]); i--) {

UI\Util.cs (5)

965if (Char.IsDigit(value[0]) || value[0] == '-' || ((!allowMultiple) && (value.IndexOf(',') >= 0))) 997if (Char.IsWhiteSpace(s[i])) 1009if (!Char.IsWhiteSpace(s[i])) 1055if (i == 0 && Char.IsDigit(s[0])) 1058if (Char.IsLetterOrDigit(s[i]))

UI\WebControls\FontUnit.cs (1)

161char firstChar = Char.ToLower(value[0], CultureInfo.InvariantCulture);

UI\WebControls\TreeView.cs (1)

2321if (!Char.IsDigit(s[i])) {

Util\altserialization.cs (1)

80else if (value is Char) {

Util\FileUtil.cs (1)

324private static Char[] _invalidFileNameChars = Path.GetInvalidFileNameChars();

Util\ParseHttpDate.cs (3)

117} else if ( ((Char.ToUpper(s[0 + startIndex], CultureInfo.InvariantCulture)) == monthString[0]) && 118((Char.ToLower(s[1 + startIndex], CultureInfo.InvariantCulture)) == monthString[1]) && 119((Char.ToLower(s[2 + startIndex], CultureInfo.InvariantCulture)) == monthString[2]) ) {

Util\SymbolEqualComparer.cs (4)

53UnicodeCategory catLeft = Char.GetUnicodeCategory(charLeft); 54UnicodeCategory catRight = Char.GetUnicodeCategory(charRight); 57if (Char.ToLower(charLeft, CultureInfo.InvariantCulture) == charRight) { 62if (Char.ToLower(charRight, CultureInfo.InvariantCulture) == charLeft) {

Util\Utf16StringValidator.cs (4)

32if (Char.IsSurrogate(input[i])) { 50if (Char.IsLowSurrogate(thisChar)) { 55if (Char.IsHighSurrogate(thisChar)) { 58if (i + 1 < chars.Length && Char.IsLowSurrogate(chars[i + 1])) {

Common\DataManager\DataPoint.cs (3)

188 Char.IsDigit(sortBy[1])) 1245 if(!Char.IsNumber(fieldName, 0)) 1463 if(!Char.IsNumber(field, 0))

WebForm\ChartWebControl.cs (2)

779foreach (Char c in str) 781 if(!Char.IsDigit(c))

DynamicData\DataSourceUtil.cs (1)

33typeNameToTypeCode[typeof(Char)] = TypeCode.Char;

System\Data\WebControls\EntityDataSourceUtil.cs (1)

325return typeof(Char);

Compilation\WCFBuildProvider.cs (2)

506if (i == 0 && Char.IsDigit(typeName[0])) 509if (Char.IsLetterOrDigit(typeName[i]))

Compilation\WCFModel\ExternalFile.cs (1)

139if (fileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || fileName.IndexOfAny(new Char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar, Path.VolumeSeparatorChar }) >= 0)

Script\Serialization\JavaScriptObjectDeserializer.cs (12)

52Nullable<Char> c = _s.GetNextNonEmptyChar(); 85Nullable<Char> c = _s.MoveNext(); 119Nullable<Char> c = _s.MoveNext(); 191Nullable<Char> c = _s.GetNextNonEmptyChar(); 272Nullable<Char> c = null; 274if (Char.IsLetterOrDigit(c.Value) || c.Value == '.' || 292Nullable<Char> c = _s.MoveNext(); 295Char quoteChar = CheckQuoteChar(c); 353Char quoteChar = '"'; 389private static bool IsNextElementArray(Nullable<Char> c) { 403private static bool IsNextElementObject(Nullable<Char> c) { 407private static bool IsNextElementString(Nullable<Char> c) {

Script\Serialization\JavaScriptSerializer.cs (1)

415if (o is Char) {

Script\Serialization\JavaScriptString.cs (1)

24if (!Char.IsWhiteSpace(c)) {

UI\WebControls\Dynamic.cs (9)

601typeof(Char), 1819while (Char.IsWhiteSpace(ch)) NextChar(); 1959if (Char.IsDigit(ch)) { 1963} while (Char.IsDigit(ch)); 1970} while (Char.IsDigit(ch)); 1979} while (Char.IsDigit(ch)); 2004return (1 << (int)Char.GetUnicodeCategory(ch) & mask) != 0; 2021return (1 << (int)Char.GetUnicodeCategory(ch) & mask) != 0; 2036if (!Char.IsDigit(ch)) throw ParseError(textPos, AtlasWeb.ExpressionParser_DigitExpected);

UI\MobileControls\Adapters\ChtmlImageAdapter.cs (1)

53writer.Write(Char.ToUpper(symbolChars[0], CultureInfo.InvariantCulture));

UI\MobileControls\Adapters\EmptyTextWriter.cs (2)

344if (c != '\r' && c != '\n' && !Char.IsWhiteSpace(c)) 373if (c != '\r' && c != '\n' && !Char.IsWhiteSpace(c))

UI\MobileControls\Adapters\HtmlLabelAdapter.cs (1)

53if(!Char.IsWhiteSpace(c))

UI\MobileControls\Adapters\UpWmlMobileTextWriter.cs (3)

116Char c = filePathSuffix[_filePathSuffixLength - 1]; 117if (Char.IsDigit(c)) 119_sessionCount = (int)Char.GetNumericValue(c);

UI\MobileControls\Adapters\XhtmlAdapters\XhtmlMobileTextWriter.cs (3)

764public override void WriteLine(Char[] buffer, Int32 index, Int32 count) { 774public override void WriteLine(Char[] v) { 784public override void WriteLine(Char v) {

UI\MobileControls\Design\Adapters\DesignerTextViewAdapter.cs (1)

283if (Char.IsWhiteSpace(text[i]))

UI\MobileControls\DeviceSpecificChoice.cs (2)

263Char.ToLower(name[0], CultureInfo.InvariantCulture) == 'o' && 264Char.ToLower(name[1], CultureInfo.InvariantCulture) == 'n')

UI\MobileControls\LiteralText.cs (4)

92if (c == '.' && Char.IsWhiteSpace((char)lastChar)) 101else if (foundSpace < 0 && Char.IsWhiteSpace(c)) // check performance of this 141while (start < stop && Char.IsWhiteSpace(text[start]) ) 149while (Char.IsWhiteSpace(text[stop - 1]) && stop > start)

UI\MobileControls\LiteralTextParser.cs (5)

169if (!Char.IsWhiteSpace(c) && 300!Char.IsWhiteSpace(literalText[tagNameFinish]) && literalText[tagNameFinish] != '/') 453if (Char.IsWhiteSpace(c)) 479if (c == '=' || Char.IsWhiteSpace(c)) 530((Char.IsWhiteSpace(c) || c == '\0') && quoteChar == '\0'))

UI\MobileControls\MobileControl.cs (2)

956else if (!Char.IsWhiteSpace(c)) 969else if (!Char.IsWhiteSpace(c))

UI\MobileControls\TextView.cs (2)

235if (Char.IsWhiteSpace(c) || Char.IsPunctuation(c))

winforms\Managed\System\Resources\ResXFileRef.cs (2)

135if ((path1[i] != path2[i]) && (compareCase || (Char.ToLower(path1[i], CultureInfo.InvariantCulture) != Char.ToLower(path2[i], CultureInfo.InvariantCulture))))

winforms\Managed\System\WinForms\AxHost.cs (1)

2116msg.wParam = (IntPtr) Char.ToUpper(charCode, CultureInfo.CurrentCulture);

winforms\Managed\System\WinForms\Control.cs (4)

7696char c2 = Char.ToUpper(charCode, CultureInfo.CurrentCulture); 7703char c1 = Char.ToUpper(text[pos], CultureInfo.CurrentCulture); 7705if (c1 == c2 || Char.ToLower(c1, CultureInfo.CurrentCulture) == Char.ToLower(c2, CultureInfo.CurrentCulture)) {

winforms\Managed\System\WinForms\DomainUpDown.cs (1)

416UnicodeCategory uc = Char.GetUnicodeCategory(character[0]);

winforms\Managed\System\WinForms\Menu.cs (2)

634char menuKey = Char.ToUpper((char) NativeMethods.Util.LOWORD(m.WParam), CultureInfo.CurrentCulture); 671Char.ToUpper(mi.Text[0], CultureInfo.CurrentCulture) == key;

winforms\Managed\System\WinForms\NumericUpDown.cs (1)

531if (Char.IsDigit(e.KeyChar)) {

winforms\Managed\System\WinForms\SendKeys.cs (5)

427&& !Char.IsWhiteSpace(keys[j])) { 441if (Char.IsWhiteSpace(keys[j])) { 443while (j < keysLen && Char.IsWhiteSpace(keys[j])) { 451if (Char.IsDigit(keys[j])) { 453while (j < keysLen && Char.IsDigit(keys[j])) {

winforms\Managed\System\WinForms\TableLayoutSettingsTypeConverter.cs (1)

201while (Char.IsLetter(styleString[nextIndex])) {

winforms\Managed\System\WinForms\ToolStrip.cs (4)

2759char charToCompare = Char.ToUpper(charCode, CultureInfo.CurrentCulture); 2760char firstLetter = Char.ToUpper(text[0], CultureInfo.CurrentCulture); 2761if (firstLetter == charToCompare ||(Char.ToLower(charCode, CultureInfo.CurrentCulture) == Char.ToLower(text[0], CultureInfo.CurrentCulture)) ) {

winforms\Managed\System\WinForms\WebBrowserBase.cs (1)

394msg.wParam = (IntPtr) Char.ToUpper(charCode, CultureInfo.CurrentCulture);

winforms\Managed\System\WinForms\WinFormsUtils.cs (2)

274mnemonic = Char.ToUpper(text[i+1], CultureInfo.CurrentCulture); 277mnemonic = Char.ToLower(text[i+1], CultureInfo.CurrentCulture);

Common\DataManager\DataPoint.cs (3)

188 Char.IsDigit(sortBy[1])) 1245 if(!Char.IsNumber(fieldName, 0)) 1463 if(!Char.IsNumber(field, 0))

Common\CompModHelpers.cs (3)

391if (Char.IsUpper(baseIdentifier[i]) && (i == 0 || i == baseIdentifier.Length - 1 || Char.IsUpper(baseIdentifier[i + 1]))) 393b.Append(Char.ToLowerInvariant(baseIdentifier[i]));

LocalService\CorrelationResolver.cs (2)

164string[] split = locationPath.Split(new Char[] { '.' }); 367string[] split = location.Split(new Char[] { '.' });

AuthoringOM\Bind.cs (1)

1771private const char NullChar = Char.MinValue;

AuthoringOM\Serializer\WorkflowMarkupSerializer.cs (5)

2667Char quoteChar = '\''; 2688if (!nonWhitespaceFound && !Char.IsWhiteSpace(args[i])) 2780else if (list.Count == 0 || list[list.Count - 1] is Char) 2804else if (list.Count > 0 && (list[list.Count - 1] is Char)) 2834if (!Char.IsWhiteSpace(args[i]))

Shared\CompModHelpers.cs (3)

389if (Char.IsUpper(baseIdentifier[i]) && (i == 0 || i == baseIdentifier.Length - 1 || Char.IsUpper(baseIdentifier[i + 1]))) 391b.Append(Char.ToLowerInvariant(baseIdentifier[i]));

System\Workflow\Activities\ValidationHelper.cs (1)

34UnicodeCategory uc = Char.GetUnicodeCategory(ch);

System\Xml\Core\XmlTextWriter.cs (2)

740public override void WriteChars(Char[] buffer, int index, int count) { 752public override void WriteRaw(Char[] buffer, int index, int count) {

System\Xml\Core\XmlWellFormedWriter.cs (2)

854if (Char.IsSurrogate(ch)) { 874if (!Char.IsSurrogatePair(highChar, lowChar)) {

System\Xml\Core\XmlWellFormedWriterAsync.cs (2)

705if (Char.IsSurrogate(ch)) { 725if (!Char.IsSurrogatePair(highChar, lowChar)) {

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

96if (Char.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber) 102UnicodeCategory uc = Char.GetUnicodeCategory(c);

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

175WriteElementString(@"char", @"", FromChar(((System.Char)o)));

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

2131new Type[] { typeof(Char[]) },

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

487if (!Char.IsDigit(name, j)) {

System\Xml\XmlConvert.cs (4)

636public static string ToString(Char value) { 844public static Char ToChar (string s) { 855internal static Exception TryToChar(string s, out Char result) { 856if (!Char.TryParse(s, out result)) {

MS\Internal\AutomationProxies\WindowsMenu.cs (2)

2470return string.Format(CultureInfo.CurrentCulture, "{0}{1}{2}", sCanonicalsKeyword, menuText.Substring(pos + cKeyChars + 1, cMenuChars - (pos + cKeyChars + 2)), Char.ToUpper(menuText[cMenuChars - 1], CultureInfo.InvariantCulture)); 2491for (pos = cChars - 1; pos > 0 && cChars - pos <= 2 && Char.IsDigit (menuText [pos]); pos--)

Base\MS\Internal\IO\Packaging\CompoundFile\ContainerUtilities.cs (2)

367if (Char.IsWhiteSpace(backSlashPath[0]) || 368Char.IsWhiteSpace(backSlashPath[backSlashPath.Length - 1]))

Base\MS\Internal\IO\Packaging\PieceNameHelper.cs (2)

391if (Char.ToUpperInvariant(input[position]) != Char.ToUpperInvariant(query[queryPosition]))

Base\System\Windows\Input\KeyConverter.cs (5)

128return Char.ToString((char)(int)(key - Key.D0 + '0')); 133return Char.ToString((char)(int)(key - Key.A + 'A')); 154if (keyToken.Length == 1 && Char.IsLetterOrDigit(keyToken[0])) 156if (Char.IsDigit(keyToken[0]) && (keyToken[0] >= '0' && keyToken[0] <= '9')) 160else if (Char.IsLetter(keyToken[0]) && (keyToken[0] >= 'A' && keyToken[0] <= 'Z'))