public AddressingDictionary(ServiceModelDictionary dictionary) { this.Action = dictionary.CreateString("Action", 5); this.To = dictionary.CreateString("To", 6); this.RelatesTo = dictionary.CreateString("RelatesTo", 9); this.MessageId = dictionary.CreateString("MessageID", 13); this.Address = dictionary.CreateString("Address", 0x15); this.ReplyTo = dictionary.CreateString("ReplyTo", 0x16); this.Empty = dictionary.CreateString("", 0x51); this.From = dictionary.CreateString("From", 0x52); this.FaultTo = dictionary.CreateString("FaultTo", 0x53); this.EndpointReference = dictionary.CreateString("EndpointReference", 0x54); this.PortType = dictionary.CreateString("PortType", 0x55); this.ServiceName = dictionary.CreateString("ServiceName", 0x56); this.PortName = dictionary.CreateString("PortName", 0x57); this.ReferenceProperties = dictionary.CreateString("ReferenceProperties", 0x58); this.RelationshipType = dictionary.CreateString("RelationshipType", 0x59); this.Reply = dictionary.CreateString("Reply", 90); this.Prefix = dictionary.CreateString("a", 0x5b); this.IdentityExtensionNamespace = dictionary.CreateString("http://schemas.xmlsoap.org/ws/2006/02/addressingidentity", 0x5c); this.Identity = dictionary.CreateString("Identity", 0x5d); this.Spn = dictionary.CreateString("Spn", 0x5e); this.Upn = dictionary.CreateString("Upn", 0x5f); this.Rsa = dictionary.CreateString("Rsa", 0x60); this.Dns = dictionary.CreateString("Dns", 0x61); this.X509v3Certificate = dictionary.CreateString("X509v3Certificate", 0x62); this.ReferenceParameters = dictionary.CreateString("ReferenceParameters", 100); this.IsReferenceParameter = dictionary.CreateString("IsReferenceParameter", 0x65); }
public override bool TryAdd (XmlDictionaryString value, out int key) { if (!base.TryAdd (value, out key)) return false; List.Add (value); return true; }
public XmlDictionaryString Add(int id, string value) { if (id < 0) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(SR.Format(SR.XmlInvalidID))); if (value == null) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value"); XmlDictionaryString xmlString; if (TryLookup(id, out xmlString)) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.XmlIDDefined))); xmlString = new XmlDictionaryString(this, value, id); if (id >= MaxArrayEntries) { if (_stringDict == null) _stringDict = new Dictionary<int, XmlDictionaryString>(); _stringDict.Add(id, xmlString); } else { if (_strings == null) { _strings = new XmlDictionaryString[Math.Max(id + 1, 16)]; } else if (id >= _strings.Length) { XmlDictionaryString[] newStrings = new XmlDictionaryString[Math.Min(Math.Max(id + 1, _strings.Length * 2), MaxArrayEntries)]; Array.Copy(_strings, 0, newStrings, 0, _strings.Length); _strings = newStrings; } _strings[id] = xmlString; } return xmlString; }
public bool TryLookup(string value, out XmlDictionaryString result) { if (value == null) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value"); if (_strings != null) { for (int i = 0; i < _strings.Length; i++) { XmlDictionaryString s = _strings[i]; if (s != null && s.Value == value) { result = s; return true; } } } if (_stringDict != null) { foreach (XmlDictionaryString s in _stringDict.Values) { if (s.Value == value) { result = s; return true; } } } result = null; return false; }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace) { if (type == null) { throw new ArgumentNullException("type"); } if (declaredType == null) { throw new ArgumentNullException("declaredType"); } if (knownTypeResolver == null) { throw new ArgumentNullException("knownTypeResolver"); } if (knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace)) { return(true); } if (type.IsPrimitive && declaredType == typeof(object)) { return(knownTypeResolver.TryResolveType(type, type, knownTypeResolver, out typeName, out typeNamespace)); } XmlDictionary dict = new XmlDictionary(); typeNamespace = dict.Add(xmlNamespace); typeName = dict.Add(type.AssemblyQualifiedName); return(true); }
private EnvelopeVersion(string ultimateReceiverActor, string nextDestinationActorValue, string ns, XmlDictionaryString dictionaryNs, string actor, XmlDictionaryString dictionaryActor, string toStringFormat, string senderFaultName, string receiverFaultName) { _toStringFormat = toStringFormat; _ultimateDestinationActor = ultimateReceiverActor; _nextDestinationActorValue = nextDestinationActorValue; _ns = ns; _dictionaryNs = dictionaryNs; _actor = actor; _dictionaryActor = dictionaryActor; _senderFaultName = senderFaultName; _receiverFaultName = receiverFaultName; if (ultimateReceiverActor != null) { if (ultimateReceiverActor.Length == 0) { _mustUnderstandActorValues = new string[] { "", nextDestinationActorValue }; _ultimateDestinationActorValues = new string[] { "", nextDestinationActorValue }; } else { _mustUnderstandActorValues = new string[] { "", ultimateReceiverActor, nextDestinationActorValue }; _ultimateDestinationActorValues = new string[] { "", ultimateReceiverActor, nextDestinationActorValue }; } } }
/// <summary> /// Creates an instance of a class that inherits from <see cref="T:System.Runtime.Serialization.XmlObjectSerializer" /> /// for serialization and deserialization processes with an <see cref="T:System.Xml.XmlDictionaryString" /> that /// contains the namespace. /// </summary> /// <param name="type">The type to serialize or deserialize.</param> /// <param name="name">The name of the serialized type.</param> /// <param name="ns">An <see cref="T:System.Xml.XmlDictionaryString" /> that contains the namespace of the serialized type.</param> /// <param name="knownTypes"> /// An <see cref="T:System.Collections.Generic.IList`1" /> of <see cref="T:System.Type" /> that /// contains known types. /// </param> /// <returns> /// An instance of a class that inherits from the <see cref="T:System.Runtime.Serialization.XmlObjectSerializer" /> /// class. /// </returns> public override XmlObjectSerializer CreateSerializer(Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes) { Argument.IsNotNull("type", type); return new BinarySerializer(type); }
public ExclusiveC14NDictionary(IXmlDictionary dictionary) { this.Namespace = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/10/xml-exc-c14n#"); this.PrefixList = this.LookupDictionaryString(dictionary, "PrefixList"); this.InclusiveNamespaces = this.LookupDictionaryString(dictionary, "InclusiveNamespaces"); this.Prefix = this.LookupDictionaryString(dictionary, "ec"); }
private void CheckActualArrayLength(int expectedLength, int actualLength, XmlDictionaryString itemName, XmlDictionaryString itemNamespace) { if (expectedLength != actualLength) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("ArrayExceededSizeAttribute", new object[] { expectedLength, itemName.Value, itemNamespace.Value }))); } }
public bool TryLookup(int key, out XmlDictionaryString value) { const int keyThreshold = 32; if (key < 0 || key >= count) { value = null; return false; } XmlDictionaryString s; if (key < keyThreshold) { if (dictionaryStrings1 == null) dictionaryStrings1 = new XmlDictionaryString[keyThreshold]; s = dictionaryStrings1[key]; if (s == null) { s = CreateString(strings[key], key); dictionaryStrings1[key] = s; } } else { if (dictionaryStrings2 == null) dictionaryStrings2 = new XmlDictionaryString[count - keyThreshold]; s = dictionaryStrings2[key - keyThreshold]; if (s == null) { s = CreateString(strings[key], key); dictionaryStrings2[key - keyThreshold] = s; } } value = s; return true; }
public XmlSignatureDictionary(IdentityModelDictionary dictionary) { this.Algorithm = dictionary.CreateString("Algorithm", 0); this.URI = dictionary.CreateString("URI", 1); this.Reference = dictionary.CreateString("Reference", 2); this.Transforms = dictionary.CreateString("Transforms", 4); this.Transform = dictionary.CreateString("Transform", 5); this.DigestMethod = dictionary.CreateString("DigestMethod", 6); this.DigestValue = dictionary.CreateString("DigestValue", 7); this.Namespace = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#", 8); this.EnvelopedSignature = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#enveloped-signature", 9); this.KeyInfo = dictionary.CreateString("KeyInfo", 10); this.Signature = dictionary.CreateString("Signature", 11); this.SignedInfo = dictionary.CreateString("SignedInfo", 12); this.CanonicalizationMethod = dictionary.CreateString("CanonicalizationMethod", 13); this.SignatureMethod = dictionary.CreateString("SignatureMethod", 14); this.SignatureValue = dictionary.CreateString("SignatureValue", 15); this.KeyName = dictionary.CreateString("KeyName", 0x52); this.Type = dictionary.CreateString("Type", 0x53); this.MgmtData = dictionary.CreateString("MgmtData", 0x54); this.Prefix = dictionary.CreateString("", 0x55); this.KeyValue = dictionary.CreateString("KeyValue", 0x56); this.RsaKeyValue = dictionary.CreateString("RSAKeyValue", 0x57); this.Modulus = dictionary.CreateString("Modulus", 0x58); this.Exponent = dictionary.CreateString("Exponent", 0x59); this.X509Data = dictionary.CreateString("X509Data", 90); this.X509IssuerSerial = dictionary.CreateString("X509IssuerSerial", 0x5b); this.X509IssuerName = dictionary.CreateString("X509IssuerName", 0x5c); this.X509SerialNumber = dictionary.CreateString("X509SerialNumber", 0x5d); this.X509Certificate = dictionary.CreateString("X509Certificate", 0x5e); }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (type == null) { typeName = null; typeNamespace = null; return false; } if (declaredType != null && declaredType.GetTypeInfo().IsInterface && CollectionDataContract.IsCollectionInterface(declaredType)) { typeName = null; typeNamespace = null; return true; } DataContract contract = DataContract.GetDataContract(type); if (_context.IsKnownType(contract, contract.KnownDataContracts, declaredType)) { typeName = contract.Name; typeNamespace = contract.Namespace; return true; } else { typeName = null; typeNamespace = null; return false; } }
private void ReflectionInitArgs(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces) { _arg0XmlReader = xmlReader; _arg1Context = context; _arg2MemberNames = memberNames; _arg3MemberNamespaces = memberNamespaces; }
public XmlSignatureDictionary(IXmlDictionary dictionary) { this.Algorithm = this.LookupDictionaryString(dictionary, "Algorithm"); this.URI = this.LookupDictionaryString(dictionary, "URI"); this.Reference = this.LookupDictionaryString(dictionary, "Reference"); this.Transforms = this.LookupDictionaryString(dictionary, "Transforms"); this.Transform = this.LookupDictionaryString(dictionary, "Transform"); this.DigestMethod = this.LookupDictionaryString(dictionary, "DigestMethod"); this.DigestValue = this.LookupDictionaryString(dictionary, "DigestValue"); this.Namespace = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#"); this.EnvelopedSignature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#enveloped-signature"); this.KeyInfo = this.LookupDictionaryString(dictionary, "KeyInfo"); this.Signature = this.LookupDictionaryString(dictionary, "Signature"); this.SignedInfo = this.LookupDictionaryString(dictionary, "SignedInfo"); this.CanonicalizationMethod = this.LookupDictionaryString(dictionary, "CanonicalizationMethod"); this.SignatureMethod = this.LookupDictionaryString(dictionary, "SignatureMethod"); this.SignatureValue = this.LookupDictionaryString(dictionary, "SignatureValue"); this.KeyName = this.LookupDictionaryString(dictionary, "KeyName"); this.Type = this.LookupDictionaryString(dictionary, "Type"); this.MgmtData = this.LookupDictionaryString(dictionary, "MgmtData"); this.Prefix = this.LookupDictionaryString(dictionary, ""); this.KeyValue = this.LookupDictionaryString(dictionary, "KeyValue"); this.RsaKeyValue = this.LookupDictionaryString(dictionary, "RSAKeyValue"); this.Modulus = this.LookupDictionaryString(dictionary, "Modulus"); this.Exponent = this.LookupDictionaryString(dictionary, "Exponent"); this.X509Data = this.LookupDictionaryString(dictionary, "X509Data"); this.X509IssuerSerial = this.LookupDictionaryString(dictionary, "X509IssuerSerial"); this.X509IssuerName = this.LookupDictionaryString(dictionary, "X509IssuerName"); this.X509SerialNumber = this.LookupDictionaryString(dictionary, "X509SerialNumber"); this.X509Certificate = this.LookupDictionaryString(dictionary, "X509Certificate"); }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace)) return true; string typeNameString = null; if (Resolver.IsCollection(type)) { TryGetCollectionTypeName(type, knownTypeResolver, out typeNameString); } else if (Resolver.IsArray(type)) { TryGetArrayTypeName(type, knownTypeResolver, out typeNameString); } if (typeNameString != null) { typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, Namespaces.DEFAULT, 0); typeName = new XmlDictionaryString(XmlDictionary.Empty, typeNameString, 0); return true; } return false; }
private void ReflectionReadMembers(object obj, XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces) { int memberCount = _classContract.MemberNames.Length; context.IncrementItemCount(memberCount); int memberIndex = -1; int firstRequiredMember; bool[] requiredMembers = GetRequiredMembers(_classContract, out firstRequiredMember); bool hasRequiredMembers = (firstRequiredMember < memberCount); int requiredIndex = hasRequiredMembers ? firstRequiredMember : -1; int index = -1; while (true) { if (!XmlObjectSerializerReadContext.MoveToNextElement(xmlReader)) { return; } if (hasRequiredMembers) { index = context.GetMemberIndexWithRequiredMembers(xmlReader, memberNames, memberNamespaces, memberIndex, requiredIndex, null); } else { index = context.GetMemberIndex(xmlReader, memberNames, memberNamespaces, memberIndex, null); } ReflectionReadMember(obj, index, xmlReader, context, memberNames, memberNamespaces); memberIndex = index; requiredIndex = index + 1; } }
public int GetJsonMemberIndex(XmlReaderDelegator xmlReader, XmlDictionaryString[] memberNames, int memberIndex, ExtensionDataObject extensionData) { int length = memberNames.Length; if (length != 0) { for (int i = 0, index = (memberIndex + 1) % length; i < length; i++, index = (index + 1) % length) { if (xmlReader.IsStartElement(memberNames[index], XmlDictionaryString.Empty)) { return index; } } string name; if (TryGetJsonLocalName(xmlReader, out name)) { for (int i = 0, index = (memberIndex + 1) % length; i < length; i++, index = (index + 1) % length) { if (memberNames[index].Value == name) { return index; } } } } HandleMemberNotFound(xmlReader, extensionData, memberIndex); return length; }
public bool TryLookup(XmlDictionaryString key, out XmlDictionaryString value) { if (key == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("key")); if (key.Dictionary == this) { value = key; return true; } if (key.Dictionary == CurrentVersion) { if (_versionedDictionaryStrings == null) _versionedDictionaryStrings = new XmlDictionaryString[CurrentVersion._count]; XmlDictionaryString s = _versionedDictionaryStrings[key.Key]; if (s == null) { if (!TryLookup(key.Value, out s)) { value = null; return false; } _versionedDictionaryStrings[key.Key] = s; } value = s; return true; } value = null; return false; }
public OleTxTransactionExternalDictionary(ServiceModelDictionary dictionary) { this.Namespace = dictionary.CreateString("http://schemas.microsoft.com/ws/2006/02/tx/oletx", 0x160); this.Prefix = dictionary.CreateString("oletx", 0x161); this.OleTxTransaction = dictionary.CreateString("OleTxTransaction", 0x162); this.PropagationToken = dictionary.CreateString("PropagationToken", 0x163); }
public ExclusiveC14NDictionary(ServiceModelDictionary dictionary) { this.Namespace = dictionary.CreateString("http://www.w3.org/2001/10/xml-exc-c14n#", 0x6f); this.PrefixList = dictionary.CreateString("PrefixList", 0x70); this.InclusiveNamespaces = dictionary.CreateString("InclusiveNamespaces", 0x71); this.Prefix = dictionary.CreateString("ec", 0x72); }
void CheckDictionaryStringArgs (XmlDictionaryString localName, XmlDictionaryString namespaceUri) { if (localName == null) throw new ArgumentNullException ("localName"); if (namespaceUri == null) throw new ArgumentNullException ("namespaceUri"); }
public SecureConversationDec2005Dictionary(XmlDictionary dictionary) { base.SecurityContextToken = dictionary.Add("SecurityContextToken"); base.AlgorithmAttribute = dictionary.Add("Algorithm"); base.Generation = dictionary.Add("Generation"); base.Label = dictionary.Add("Label"); base.Offset = dictionary.Add("Offset"); base.Properties = dictionary.Add("Properties"); base.Identifier = dictionary.Add("Identifier"); base.Cookie = dictionary.Add("Cookie"); base.RenewNeededFaultCode = dictionary.Add("RenewNeeded"); base.BadContextTokenFaultCode = dictionary.Add("BadContextToken"); base.Prefix = dictionary.Add("sc"); base.DerivedKeyTokenType = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/dk"); base.SecurityContextTokenType = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct"); base.SecurityContextTokenReferenceValueType = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct"); base.RequestSecurityContextIssuance = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT"); base.RequestSecurityContextIssuanceResponse = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT"); this.RequestSecurityContextRenew = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Renew"); this.RequestSecurityContextRenewResponse = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT/Renew"); this.RequestSecurityContextClose = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Cancel"); this.RequestSecurityContextCloseResponse = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT/Cancel"); base.Namespace = dictionary.Add("http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512"); base.DerivedKeyToken = dictionary.Add("DerivedKeyToken"); base.Nonce = dictionary.Add("Nonce"); base.Length = dictionary.Add("Length"); this.Instance = dictionary.Add("Instance"); }
public SecurityAlgorithmDictionary(ServiceModelDictionary dictionary) { this.Aes128Encryption = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#aes128-cbc", 0x8a); this.Aes128KeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#kw-aes128", 0x8b); this.Aes192Encryption = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#aes192-cbc", 140); this.Aes192KeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#kw-aes192", 0x8d); this.Aes256Encryption = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#aes256-cbc", 0x8e); this.Aes256KeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#kw-aes256", 0x8f); this.DesEncryption = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#des-cbc", 0x90); this.DsaSha1Signature = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#dsa-sha1", 0x91); this.ExclusiveC14n = dictionary.CreateString("http://www.w3.org/2001/10/xml-exc-c14n#", 0x6f); this.ExclusiveC14nWithComments = dictionary.CreateString("http://www.w3.org/2001/10/xml-exc-c14n#WithComments", 0x92); this.HmacSha1Signature = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#hmac-sha1", 0x93); this.HmacSha256Signature = dictionary.CreateString("http://www.w3.org/2001/04/xmldsig-more#hmac-sha256", 0x94); this.Psha1KeyDerivation = dictionary.CreateString("http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1", 0x95); this.Ripemd160Digest = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#ripemd160", 150); this.RsaOaepKeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p", 0x97); this.RsaSha1Signature = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#rsa-sha1", 0x98); this.RsaSha256Signature = dictionary.CreateString("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256", 0x99); this.RsaV15KeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#rsa-1_5", 0x9a); this.Sha1Digest = dictionary.CreateString("http://www.w3.org/2000/09/xmldsig#sha1", 0x9b); this.Sha256Digest = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#sha256", 0x9c); this.Sha512Digest = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#sha512", 0x9d); this.TripleDesEncryption = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#tripledes-cbc", 0x9e); this.TripleDesKeyWrap = dictionary.CreateString("http://www.w3.org/2001/04/xmlenc#kw-tripledes", 0x9f); this.TlsSspiKeyWrap = dictionary.CreateString("http://schemas.xmlsoap.org/2005/02/trust/tlsnego#TLS_Wrap", 160); this.WindowsSspiKeyWrap = dictionary.CreateString("http://schemas.xmlsoap.org/2005/02/trust/spnego#GSS_Wrap", 0xa1); }
internal bool IsLocalName(XmlDictionaryString localName) { if (dictionaryReader == null) return localName.Value == reader.LocalName; else return dictionaryReader.IsLocalName(localName); }
EnvelopeVersion(string ultimateReceiverActor, string nextDestinationActorValue, string ns, XmlDictionaryString dictionaryNs, string actor, XmlDictionaryString dictionaryActor, string toStringFormat, string senderFaultName, string receiverFaultName) { this.toStringFormat = toStringFormat; this.ultimateDestinationActor = ultimateReceiverActor; this.nextDestinationActorValue = nextDestinationActorValue; this.ns = ns; this.dictionaryNs = dictionaryNs; this.actor = actor; this.dictionaryActor = dictionaryActor; this.senderFaultName = senderFaultName; this.receiverFaultName = receiverFaultName; if (ultimateReceiverActor != null) { if (ultimateReceiverActor.Length == 0) { mustUnderstandActorValues = new string[] { "", nextDestinationActorValue }; ultimateDestinationActorValues = new string[] { "", nextDestinationActorValue }; } else { mustUnderstandActorValues = new string[] { "", ultimateReceiverActor, nextDestinationActorValue }; ultimateDestinationActorValues = new string[] { "", ultimateReceiverActor, nextDestinationActorValue }; } } }
public ExclusiveC14NDictionary(IdentityModelDictionary dictionary) { this.Namespace = dictionary.CreateString("http://www.w3.org/2001/10/xml-exc-c14n#", 20); this.PrefixList = dictionary.CreateString("PrefixList", 0x15); this.InclusiveNamespaces = dictionary.CreateString("InclusiveNamespaces", 0x16); this.Prefix = dictionary.CreateString("ec", 0x17); }
internal bool IsNamespaceUri(XmlDictionaryString ns) { if (dictionaryReader == null) return ns.Value == reader.NamespaceURI; else return dictionaryReader.IsNamespaceUri(ns); }
public Wsrm11Dictionary(XmlDictionary dictionary) { this.AckRequestedAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/AckRequested"); this.CloseSequence = dictionary.Add("CloseSequence"); this.CloseSequenceAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequence"); this.CloseSequenceResponse = dictionary.Add("CloseSequenceResponse"); this.CloseSequenceResponseAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequenceResponse"); this.CreateSequenceAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/CreateSequence"); this.CreateSequenceResponseAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/CreateSequenceResponse"); this.DiscardFollowingFirstGap = dictionary.Add("DiscardFollowingFirstGap"); this.Endpoint = dictionary.Add("Endpoint"); this.FaultAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/fault"); this.Final = dictionary.Add("Final"); this.IncompleteSequenceBehavior = dictionary.Add("IncompleteSequenceBehavior"); this.LastMsgNumber = dictionary.Add("LastMsgNumber"); this.MaxMessageNumber = dictionary.Add("MaxMessageNumber"); this.Namespace = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702"); this.NoDiscard = dictionary.Add("NoDiscard"); this.None = dictionary.Add("None"); this.SequenceAcknowledgementAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/SequenceAcknowledgement"); this.SequenceClosed = dictionary.Add("SequenceClosed"); this.TerminateSequenceAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/TerminateSequence"); this.TerminateSequenceResponse = dictionary.Add("TerminateSequenceResponse"); this.TerminateSequenceResponseAction = dictionary.Add("http://docs.oasis-open.org/ws-rx/wsrm/200702/TerminateSequenceResponse"); this.UsesSequenceSSL = dictionary.Add("UsesSequenceSSL"); this.UsesSequenceSTR = dictionary.Add("UsesSequenceSTR"); this.WsrmRequired = dictionary.Add("WsrmRequired"); }
public SecurityJan2004Dictionary(ServiceModelDictionary dictionary) { this.SecurityTokenReference = dictionary.CreateString("SecurityTokenReference", 30); this.Namespace = dictionary.CreateString("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", 0x24); this.Security = dictionary.CreateString("Security", 0x34); this.ValueType = dictionary.CreateString("ValueType", 0x3a); this.TypeAttribute = dictionary.CreateString("Type", 0x3b); this.Prefix = dictionary.CreateString("o", 0xa4); this.NonceElement = dictionary.CreateString("Nonce", 40); this.PasswordElement = dictionary.CreateString("Password", 0xa5); this.PasswordTextName = dictionary.CreateString("PasswordText", 0xa6); this.UserNameElement = dictionary.CreateString("Username", 0xa7); this.UserNameTokenElement = dictionary.CreateString("UsernameToken", 0xa8); this.BinarySecurityToken = dictionary.CreateString("BinarySecurityToken", 0xa9); this.EncodingType = dictionary.CreateString("EncodingType", 170); this.Reference = dictionary.CreateString("Reference", 12); this.URI = dictionary.CreateString("URI", 11); this.KeyIdentifier = dictionary.CreateString("KeyIdentifier", 0xab); this.EncodingTypeValueBase64Binary = dictionary.CreateString("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary", 0xac); this.EncodingTypeValueHexBinary = dictionary.CreateString("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#HexBinary", 0xad); this.EncodingTypeValueText = dictionary.CreateString("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Text", 0xae); this.X509SKIValueType = dictionary.CreateString("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-profile-1.0#X509SubjectKeyIdentifier", 0xaf); this.KerberosTokenTypeGSS = dictionary.CreateString("http://docs.oasis-open.org/wss/oasis-wss-kerberos-token-profile-1.1#GSS_Kerberosv5_AP_REQ", 0xb0); this.KerberosTokenType1510 = dictionary.CreateString("http://docs.oasis-open.org/wss/oasis-wss-kerberos-token-profile-1.1#GSS_Kerberosv5_AP_REQ1510", 0xb1); this.SamlAssertionIdValueType = dictionary.CreateString("http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.0#SAMLAssertionID", 0xb2); this.SamlAssertion = dictionary.CreateString("Assertion", 0xb3); this.SamlUri = dictionary.CreateString("urn:oasis:names:tc:SAML:1.0:assertion", 180); this.RelAssertionValueType = dictionary.CreateString("http://docs.oasis-open.org/wss/oasis-wss-rel-token-profile-1.0.pdf#license", 0xb5); this.FailedAuthenticationFaultCode = dictionary.CreateString("FailedAuthentication", 0xb6); this.InvalidSecurityTokenFaultCode = dictionary.CreateString("InvalidSecurityToken", 0xb7); this.InvalidSecurityFaultCode = dictionary.CreateString("InvalidSecurity", 0xb8); this.KerberosHashValueType = dictionary.CreateString("http://docs.oasis-open.org/wss/oasis-wss-kerberos-token-profile-1.1#Kerberosv5APREQSHA1", 0x1ab); }
public SamlDictionary(IdentityModelDictionary dictionary) { this.Access = dictionary.CreateString("Access", 0x18); this.AccessDecision = dictionary.CreateString("AccessDecision", 0x19); this.Action = dictionary.CreateString("Action", 0x1a); this.Advice = dictionary.CreateString("Advice", 0x1b); this.Assertion = dictionary.CreateString("Assertion", 0x1c); this.AssertionId = dictionary.CreateString("AssertionID", 0x1d); this.AssertionIdReference = dictionary.CreateString("AssertionIDReference", 30); this.Attribute = dictionary.CreateString("Attribute", 0x1f); this.AttributeName = dictionary.CreateString("AttributeName", 0x20); this.AttributeNamespace = dictionary.CreateString("AttributeNamespace", 0x21); this.AttributeStatement = dictionary.CreateString("AttributeStatement", 0x22); this.AttributeValue = dictionary.CreateString("AttributeValue", 0x23); this.Audience = dictionary.CreateString("Audience", 0x24); this.AudienceRestrictionCondition = dictionary.CreateString("AudienceRestrictionCondition", 0x25); this.AuthenticationInstant = dictionary.CreateString("AuthenticationInstant", 0x26); this.AuthenticationMethod = dictionary.CreateString("AuthenticationMethod", 0x27); this.AuthenticationStatement = dictionary.CreateString("AuthenticationStatement", 40); this.AuthorityBinding = dictionary.CreateString("AuthorityBinding", 0x29); this.AuthorityKind = dictionary.CreateString("AuthorityKind", 0x2a); this.AuthorizationDecisionStatement = dictionary.CreateString("AuthorizationDecisionStatement", 0x2b); this.Binding = dictionary.CreateString("Binding", 0x2c); this.Condition = dictionary.CreateString("Condition", 0x2d); this.Conditions = dictionary.CreateString("Conditions", 0x2e); this.Decision = dictionary.CreateString("Decision", 0x2f); this.DoNotCacheCondition = dictionary.CreateString("DoNotCacheCondition", 0x30); this.Evidence = dictionary.CreateString("Evidence", 0x31); this.IssueInstant = dictionary.CreateString("IssueInstant", 50); this.Issuer = dictionary.CreateString("Issuer", 0x33); this.Location = dictionary.CreateString("Location", 0x34); this.MajorVersion = dictionary.CreateString("MajorVersion", 0x35); this.MinorVersion = dictionary.CreateString("MinorVersion", 0x36); this.Namespace = dictionary.CreateString("urn:oasis:names:tc:SAML:1.0:assertion", 0x37); this.NameIdentifier = dictionary.CreateString("NameIdentifier", 0x38); this.NameIdentifierFormat = dictionary.CreateString("Format", 0x39); this.NameIdentifierNameQualifier = dictionary.CreateString("NameQualifier", 0x3a); this.ActionNamespaceAttribute = dictionary.CreateString("Namespace", 0x3b); this.NotBefore = dictionary.CreateString("NotBefore", 60); this.NotOnOrAfter = dictionary.CreateString("NotOnOrAfter", 0x3d); this.PreferredPrefix = dictionary.CreateString("saml", 0x3e); this.Statement = dictionary.CreateString("Statement", 0x3f); this.Subject = dictionary.CreateString("Subject", 0x40); this.SubjectConfirmation = dictionary.CreateString("SubjectConfirmation", 0x41); this.SubjectConfirmationData = dictionary.CreateString("SubjectConfirmationData", 0x42); this.SubjectConfirmationMethod = dictionary.CreateString("ConfirmationMethod", 0x43); this.HolderOfKey = dictionary.CreateString("urn:oasis:names:tc:SAML:1.0:cm:holder-of-key", 0x44); this.SenderVouches = dictionary.CreateString("urn:oasis:names:tc:SAML:1.0:cm:sender-vouches", 0x45); this.SubjectLocality = dictionary.CreateString("SubjectLocality", 70); this.SubjectLocalityDNSAddress = dictionary.CreateString("DNSAddress", 0x47); this.SubjectLocalityIPAddress = dictionary.CreateString("IPAddress", 0x48); this.SubjectStatement = dictionary.CreateString("SubjectStatement", 0x49); this.UnspecifiedAuthenticationMethod = dictionary.CreateString("urn:oasis:names:tc:SAML:1.0:am:unspecified", 0x4a); this.NamespaceAttributePrefix = dictionary.CreateString("xmlns", 0x4b); this.Resource = dictionary.CreateString("Resource", 0x4c); this.UserName = dictionary.CreateString("UserName", 0x4d); this.UserNameNamespace = dictionary.CreateString("urn:oasis:names:tc:SAML:1.1:nameid-format:WindowsDomainQualifiedName", 0x4e); this.EmailName = dictionary.CreateString("EmailName", 0x4f); this.EmailNamespace = dictionary.CreateString("urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress", 80); }
public override bool TryResolveType (Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { //Console.WriteLine ("TryResolveType: {0} {1}", type, declaredType); if (knownTypeResolver.TryResolveType (type, declaredType, null, out typeName, out typeNamespace)) return true; return SafeResolveType (type, out typeName, out typeNamespace); }
public SystemInterface.Runtime.Serialization.Json.IDataContractJsonSerializer Create( System.Type type, System.Xml.XmlDictionaryString rootName) { return(new SystemWrapper.Runtime.Serialization.Json.DataContractJsonSerializerWrap( type, rootName)); }
//public ProtoOperationBehavior(OperationDescription operation, DataContractFormatAttribute dataContractFormat) : base(operation, dataContractFormat) { } /// <summary> /// Creates a protobuf serializer if possible (falling back to the default WCF serializer) /// </summary> public override XmlObjectSerializer CreateSerializer(Type type, System.Xml.XmlDictionaryString name, System.Xml.XmlDictionaryString ns, IList <Type> knownTypes) { if (model == null) { throw new InvalidOperationException("No Model instance has been assigned to the ProtoOperationBehavior"); } return(XmlProtoSerializer.TryCreate(model, type) ?? base.CreateSerializer(type, name, ns, knownTypes)); }
public SystemInterface.Runtime.Serialization.Json.IDataContractJsonSerializer Create( System.Type type, System.Xml.XmlDictionaryString rootName, System.Collections.Generic.IEnumerable <System.Type> knownTypes) { return(new SystemWrapper.Runtime.Serialization.Json.DataContractJsonSerializerWrap( type, rootName, knownTypes)); }
public override bool TryResolveType(Type type , Type declaredType , DataContractResolver knownTypeResolver , out System.Xml.XmlDictionaryString typeName , out System.Xml.XmlDictionaryString typeNamespace) { XmlDictionary dictionary = new XmlDictionary(); // 将类型放到Namespace中,放在typeName中会出现错误 typeName = dictionary.Add(ObjectTypeName); typeNamespace = dictionary.Add(type.FullName); return(true); }
public SystemInterface.Runtime.Serialization.Json.IDataContractJsonSerializer Create( System.Type type, System.Xml.XmlDictionaryString rootName, System.Collections.Generic.IEnumerable <System.Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, System.Runtime.Serialization.IDataContractSurrogate dataContractSurrogate, bool alwaysEmitTypeInformation) { return(new SystemWrapper.Runtime.Serialization.Json.DataContractJsonSerializerWrap( type, rootName, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, dataContractSurrogate, alwaysEmitTypeInformation)); }
public virtual void WriteXmlAttribute(XmlDictionaryString localName, XmlDictionaryString value) { WriteXmlAttribute(localName.Value, value.Value); }
public virtual void WriteXmlnsAttribute(string prefix, XmlDictionaryString namespaceUri) { WriteXmlnsAttribute(prefix, namespaceUri.Value); }
private void ReadNamespace(byte ident) { // create attrubute slot. if (attributes.Count == attr_count) { attributes.Add(new AttrNodeInfo(this)); } AttrNodeInfo a = attributes [attr_count++]; a.Reset(); a.Position = source.Position; string prefix = null, ns = null; XmlDictionaryString dns = null; switch (ident) { case BF.DefaultNSString: prefix = String.Empty; ns = ReadUTF8(); break; case BF.PrefixNSString: prefix = ReadUTF8(); ns = ReadUTF8(); break; case BF.DefaultNSIndex: prefix = String.Empty; dns = ReadDictName(); ns_dict_store.Add(ns_store.Count, dns); ns = dns.Value; break; case BF.PrefixNSIndex: prefix = ReadUTF8(); dns = ReadDictName(); ns_dict_store.Add(ns_store.Count, dns); ns = dns.Value; break; } // fill attribute slot. a.Prefix = prefix.Length > 0 ? "xmlns" : String.Empty; a.LocalName = prefix.Length > 0 ? prefix : "xmlns"; a.NS = "http://www.w3.org/2000/xmlns/"; a.ValueIndex = attr_value_count; if (attr_value_count == attr_values.Count) { attr_values.Add(new NodeInfo(true)); } NodeInfo v = attr_values [attr_value_count++]; v.Reset(); v.Value = ns; v.ValueType = BF.Chars8; v.NodeType = XmlNodeType.Text; ns_store.Add(new QName(prefix, ns)); context.NamespaceManager.AddNamespace(prefix, ns); }
public bool TryLookup(XmlDictionaryString value, out XmlDictionaryString result) { result = null; return(false); }
public virtual bool TryLookup(string value, out XmlDictionaryString result) { return(_lookup.TryGetValue(value, out result)); }
static public void ThrowFullStartElementExpected(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns) { ThrowFullStartElementExpected(reader, XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(ns)); }
public override XmlObjectSerializer CreateSerializer(Type type, System.Xml.XmlDictionaryString name, System.Xml.XmlDictionaryString ns, IList <Type> knownTypes) { return(new DataContractJsonSerializer(type, name, knownTypes, this.MaxItemsInObjectGraph, this.IgnoreExtensionDataObject, this.DataContractSurrogate, alwaysEmitTypeInformation)); }
public virtual void WriteXmlnsAttribute(string prefix, XmlDictionaryString namespaceUri) { WriteXmlnsAttribute(prefix, XmlDictionaryString.GetString(namespaceUri)); }
public void WriteStartElement( XmlDictionaryString localName, XmlDictionaryString namespaceUri) { WriteStartElement(null, localName, namespaceUri); }
public void WriteStartAttribute( XmlDictionaryString localName, XmlDictionaryString namespaceUri) { WriteStartAttribute(localName.Value, namespaceUri.Value); }
public virtual void WriteValue(XmlDictionaryString value) { WriteValue(value.Value); }
public void WriteAttributeString(XmlDictionaryString localName, XmlDictionaryString namespaceUri, string value) { WriteAttributeString((string)null, localName, namespaceUri, value); }
public virtual void WriteStartAttribute(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri) { WriteStartAttribute(prefix, localName.Value, namespaceUri.Value); }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace) { Debug.WriteLine("TryResolveType ", type.Name); var retVal = _typeToNames.ContainsKey(type); if (retVal) { XmlDictionary dictionary = new XmlDictionary(); typeNamespace = dictionary.Add(_typeToNames[type].Item1); typeName = dictionary.Add(_typeToNames[type].Item2); } else { retVal = knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace); } return(retVal); }
/// <summary> /// Override this method to map a data contract type to an xsi:type name and namespace during serialization. /// </summary> /// <param name="type">The type to map.</param> /// <param name="declaredType">The type declared in the data contract.</param> /// <param name="knownTypeResolver">The known type resolver.</param> /// <param name="typeName">The xsi:type name.</param> /// <param name="typeNamespace">The xsi:type namespace.</param> /// <returns> /// true if mapping succeeded; otherwise, false. /// </returns> public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace) { if (type == typeof(Tag)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add("Tag"); typeNamespace = dictionary.Add(uri); return(true); } else if (type == typeof(Entry)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add("Entry"); typeNamespace = dictionary.Add(uri); return(true); } else if (type == typeof(LinkEntry)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add("LinkEntry"); typeNamespace = dictionary.Add(uri); return(true); } else if (type == typeof(LinkItem)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add("LinkItem"); typeNamespace = dictionary.Add(uri); return(true); } else { return(knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace)); } }
public abstract void WriteQualifiedName(string prefix, XmlDictionaryString localName);
public abstract void WriteStartAttribute(string prefix, XmlDictionaryString localName);
public virtual void WriteQualifiedName( XmlDictionaryString localName, XmlDictionaryString namespaceUri) { WriteQualifiedName(localName.Value, namespaceUri.Value); }
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace) { EntityUtil.CheckArgumentNull(dataContractType, "dataContractType"); EntityUtil.CheckArgumentNull(declaredType, "declaredType"); EntityUtil.CheckArgumentNull(knownTypeResolver, "knownTypeResolver"); Type nonProxyType = ObjectContext.GetObjectType(dataContractType); if (nonProxyType != dataContractType) { // Type was a proxy type, so map the name to the non-proxy name XmlQualifiedName qualifiedName = _exporter.GetSchemaTypeName(nonProxyType); XmlDictionary dictionary = new XmlDictionary(2); typeName = new XmlDictionaryString(dictionary, qualifiedName.Name, 0); typeNamespace = new XmlDictionaryString(dictionary, qualifiedName.Namespace, 1); return(true); } else { // Type was not a proxy type, so do the default return(knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace)); } }
public abstract void WriteText(XmlDictionaryString value);
public abstract void WriteStartElement(string prefix, XmlDictionaryString localName);
public abstract void WriteXmlnsAttribute(string prefix, XmlDictionaryString ns);
//public ProtoOperationBehavior(OperationDescription operation, DataContractFormatAttribute dataContractFormat) : base(operation, dataContractFormat) { } /// <summary> /// Creates a protobuf serializer if possible (falling back to the default WCF serializer) /// </summary> public override XmlObjectSerializer CreateSerializer(Type type, System.Xml.XmlDictionaryString name, System.Xml.XmlDictionaryString ns, IList <Type> knownTypes) { return(XmlProtoSerializer.TryCreate(model, type) ?? base.CreateSerializer(type, name, ns, knownTypes)); }
// Serialization public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace) { Type[] genericTypes = type.GetGenericArguments(); string ns = string.Empty; Type genericType = null; foreach (Type genType in genericTypes) { if (typesByType.ContainsKey(genType) == true) { typesByType.TryGetValue(genType, out ns); genericType = genType; break; } } if (string.IsNullOrEmpty(ns) == false) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add(genericType.Name); typeNamespace = dictionary.Add(ns); return(true); } else { return(knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace)); } }