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; }
/// <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); }
// 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); } }
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 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 override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { var res = knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace); if (res) return res; System.Reflection.Assembly asm = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(p => p == dataContractType.Assembly); if (asm != null) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add(dataContractType.Name); typeNamespace = dictionary.Add("http://tempuri.com/" + asm.FullName); return true; } foreach (IPlugin plugin in PluginHelper.plugins.Values) { if (plugin.GetType().Assembly == dataContractType.Assembly){ XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add(dataContractType.Name); typeNamespace = dictionary.Add("http://tempuri.com/"+ plugin.Name); return true; } } return false; }
static SecureConversationVersion () { var dic = new XmlDictionary (); WSSecureConversation13 = new SecureConversationVersionImpl () { Prefix = dic.Add ("wsse"), Namespace = dic.Add ("http://schemas.xmlsoap.org/ws/2002/12/secext") }; WSSecureConversationFeb2005 = new SecureConversationVersionImpl () { Prefix = dic.Add ("wsse"), Namespace = dic.Add ("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd") }; Default = WSSecureConversation13; }
static TrustVersion () { var dic = new XmlDictionary (); WSTrust13 = new TrustVersionImpl () { Prefix = dic.Add ("wst"), Namespace = dic.Add ("http://docs.oasis-open.org/ws-sx/ws-trust/200512") }; WSTrustFeb2005 = new TrustVersionImpl () { Prefix = dic.Add ("wsse"), Namespace = dic.Add ("http://schemas.xmlsoap.org/ws/2002/12/secext") }; Default = WSTrust13; }
public InvalidDataContractCriticalHelper(Type type) : base(type) { StableName = DataContract.GetStableName(type); _xmlDictionary = new XmlDictionary(2); this.Name = this.TopLevelElementName = _xmlDictionary.Add(StableName.Name); this.Namespace = this.TopLevelElementNamespace = _xmlDictionary.Add(StableName.Namespace); }
public void Empty () { XmlDictionary d = new XmlDictionary (); XmlDictionaryString dns; d.Add (String.Empty); Assert.IsTrue (d.TryLookup (String.Empty, out dns), "#0"); Assert.AreEqual (0, dns.Key, "#1"); }
public void Add () { XmlDictionary d = new XmlDictionary (); Assert.AreEqual (0, d.Add ("foo").Key, "#1"); Assert.AreEqual (0, d.Add ("foo").Key, "#2"); Assert.AreEqual (1, d.Add ("bar").Key, "#3"); Assert.AreEqual (2, d.Add ("baz").Key, "#4"); }
internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, string rootName, string rootNs, int maxItems) { XmlDictionary dictionary = new XmlDictionary(2); return new DataContractSerializer( type, dictionary.Add(rootName), dictionary.Add(rootNs), knownTypes); }
public void TryAddDuplicate () { XmlDictionary dic = new XmlDictionary (); XmlDictionaryString d1 = dic.Add ("foo"); XmlBinaryWriterSession s = new XmlBinaryWriterSession (); int idx; s.TryAdd (d1, out idx); s.TryAdd (d1, out idx); }
private static XmlDictionaryString AddToDictionary(XmlDictionary dictionary, string s) { XmlDictionaryString str; if (!dictionary.TryLookup(s, out str)) { str = dictionary.Add(s); } return str; }
static DXD() { XmlDictionary dictionary = new XmlDictionary(0x89); atomicTransactionExternal11Dictionary = new System.ServiceModel.AtomicTransactionExternal11Dictionary(dictionary); coordinationExternal11Dictionary = new System.ServiceModel.CoordinationExternal11Dictionary(dictionary); secureConversationDec2005Dictionary = new System.ServiceModel.SecureConversationDec2005Dictionary(dictionary); securityAlgorithmDec2005Dictionary = new System.ServiceModel.SecurityAlgorithmDec2005Dictionary(dictionary); trustDec2005Dictionary = new System.ServiceModel.TrustDec2005Dictionary(dictionary); wsrm11Dictionary = new System.ServiceModel.Wsrm11Dictionary(dictionary); }
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (!knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add(dataContractType.FullName); typeNamespace = dictionary.Add(dataContractType.Assembly.FullName); } return true; }
public NetDataContractSerializer(string rootName, string rootNamespace, StreamingContext context, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, FormatterAssemblyStyle assemblyFormat, ISurrogateSelector surrogateSelector) { XmlDictionary dictionary = new XmlDictionary(2); Initialize(dictionary.Add(rootName), dictionary.Add(DataContract.GetNamespace(rootNamespace)), context, maxItemsInObjectGraph, ignoreExtensionDataObject, assemblyFormat, surrogateSelector); }
public CoordinationExternal11Dictionary(XmlDictionary dictionary) { this.Namespace = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06"); this.CreateCoordinationContextAction = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06/CreateCoordinationContext"); this.CreateCoordinationContextResponseAction = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06/CreateCoordinationContextResponse"); this.RegisterAction = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06/Register"); this.RegisterResponseAction = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06/RegisterResponse"); this.FaultAction = dictionary.Add("http://docs.oasis-open.org/ws-tx/wscoor/2006/06/fault"); this.CannotCreateContext = dictionary.Add("CannotCreateContext"); this.CannotRegisterParticipant = dictionary.Add("CannotRegisterParticipant"); }
/// <summary> /// Initializes a new instance of the Message class. /// </summary> /// <param name="to">The JID of the intended recipient.</param> /// <param name="body">The content of the message.</param> /// <param name="subject">The subject of the message.</param> /// <param name="thread">The conversation thread this message belongs to.</param> /// <param name="type">The type of the message. Can be one of the values from /// the MessagType enumeration.</param> /// <param name="language">The language of the XML character data of /// the stanza.</param> /// <exception cref="ArgumentNullException">The to parameter is null.</exception> /// <exception cref="ArgumentException">The body parameter is the empty string.</exception> public Message(Jid to, string body = null, string subject = null, string thread = null, MessageType type = MessageType.Normal, CultureInfo language = null) : base(to, null, null, null, language) { to.ThrowIfNull("to"); AlternateSubjects = new XmlDictionary(element, "subject", "xml:lang"); AlternateBodies = new XmlDictionary(element, "body", "xml:lang"); Type = type; Body = body; Subject = subject; Thread = thread; }
public override bool TryResolveType( Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { var dict = new XmlDictionary(); typeName = dict.Add(Uri.EscapeDataString(type.FullName).Replace("%", "..")); typeNamespace = dict.Add(type.Namespace); return true; }
public XmlSimpleDictionaryReader (XmlReader reader, XmlDictionary dictionary, OnXmlDictionaryReaderClose onClose) { this.reader = reader; this.onClose = onClose; as_line_info = reader as IXmlLineInfo; as_dict_reader = reader as XmlDictionaryReader; if (dictionary == null) dictionary = new XmlDictionary (); dict = dictionary; }
protected override byte [] EncodeSecurityState (byte [] src) { foreach (byte b in src) Console.Write ("{0:X02} ", b); Console.WriteLine (); // this show how it is LAMESPEC. //Array.Reverse (src); XmlDictionary dic = new XmlDictionary (); for (int i = 0; i < 60; i++) dic.Add ("n" + i); XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas (); XmlDictionaryReader cr = XmlDictionaryReader.CreateBinaryReader (src, 0, src.Length, dic, quotas); cr.Read (); XmlWriter w = XmlWriter.Create (Console.Out); while (!cr.EOF) switch (cr.NodeType) { case XmlNodeType.Element: int dummy; w.WriteStartElement (cr.Prefix, cr.LocalName, cr.NamespaceURI); for (int i = 0; i < cr.AttributeCount; i++) { cr.MoveToAttribute (i); w.WriteStartAttribute (cr.Prefix, cr.LocalName, cr.NamespaceURI); bool b64 = cr.LocalName == "n41"; while (cr.ReadAttributeValue ()) { if (b64) foreach (byte b in Convert.FromBase64String (cr.Value)) w.WriteString (String.Format ("{0:X02}-", b)); else w.WriteString (cr.Value); } w.WriteEndAttribute (); } //w.WriteAttributes (cr, false); cr.MoveToElement (); if (cr.IsEmptyElement) w.WriteEndElement (); cr.Read (); break; case XmlNodeType.EndElement: w.WriteEndElement (); cr.Read (); break; default: if (cr.TryGetBase64ContentLength (out dummy)) { foreach (byte b in cr.ReadContentAsBase64 ()) w.WriteString (String.Format ("{0:X02} ", b)); } else w.WriteNode (cr, false); break; } w.Close (); return src; }
private void useCustomStaticDictionaryToolStripMenuItem_Click(object sender, EventArgs e) { string[] allLines = this.ReadAllLinesFromDialog(); if (allLines != null) { XmlDictionary temp = new XmlDictionary(); this.staticDictionary = temp; foreach (string line in allLines) { temp.Add(line); } } }
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (Identity.ContainsKey(dataContractType)) { var dictionary = new XmlDictionary(); typeName = dictionary.Add(Identity[dataContractType]); typeNamespace = dictionary.Add(dataContractType.FullName); return true; } // Defer to the known type resolver return knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace); }
public void TryAddIndex () { XmlDictionary dic = new XmlDictionary (); XmlDictionaryString d1 = dic.Add ("foo"); XmlDictionaryString d2 = dic.Add ("bar"); XmlDictionaryString d3 = dic.Add ("baz"); XmlBinaryWriterSession s = new XmlBinaryWriterSession (); int idx; s.TryAdd (d1, out idx); Assert.AreEqual (0, idx, "#1"); s.TryAdd (d3, out idx); Assert.AreEqual (1, idx, "#2"); // not 2 }
public override bool TryResolveType (Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { var map = serializer.InternalKnownTypes.FindUserMap (type); if (map == null) { typeName = null; typeNamespace = null; return false; } else { dictionary = dictionary ?? new XmlDictionary (); typeName = dictionary.Add (map.XmlName.Name); typeNamespace = dictionary.Add (map.XmlName.Namespace); return true; } }
public XmlSimpleDictionaryReader(XmlReader reader, XmlDictionary dictionary, OnXmlDictionaryReaderClose onClose) { this.reader = reader; this.onClose = onClose; as_line_info = reader as IXmlLineInfo; as_dict_reader = reader as XmlDictionaryReader; if (dictionary == null) { dictionary = new XmlDictionary(); } dict = dictionary; }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (type.Assembly.GetName().Name == DynamicTypeBuilder.AssemblyName) { XmlDictionary dic = new XmlDictionary(); typeName = dic.Add(type.Name); typeNamespace = dic.Add(ResolverNamespace); return true; } else { return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace); } }
void DumpXmlBinary (byte [] src) { XmlDictionary dic = new XmlDictionary (); for (int i = 0; i < 12; i++) dic.Add ("n" + i); XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas (); XmlDictionaryReader cr = XmlDictionaryReader.CreateBinaryReader (src, 0, src.Length, dic, quotas); cr.Read (); XmlWriter w = XmlWriter.Create (Console.Out); while (!cr.EOF) w.WriteNode (cr, false); w.Close (); Console.WriteLine (); }
// These methods are necessary for standard .Net serialisation // For JSon we use different means, have a look in JsonBinSerializer for its custom Json.NET handler. public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (TypeIdentity.Instance.ContainsKey(dataContractType)) { XmlDictionary dictionary = new XmlDictionary(); typeName = dictionary.Add(TypeIdentity.Instance[dataContractType].Alias); typeNamespace = dictionary.Add(dataContractType.FullName); return true; // indicating that this resolver knows how to handle } else { // Defer to the known type resolver return knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace); } }
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc) { if (description == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description"); OperationFormatter.Validate(description, isRpc, false/*isEncoded*/); this.operation = description; #pragma warning suppress 56506 // Microsoft, OperationDescription.Messages never be null this.requestMessage = description.Messages[0]; if (description.Messages.Count == 2) this.responseMessage = description.Messages[1]; int stringCount = 3 + requestMessage.Body.Parts.Count; if (responseMessage != null) stringCount += 2 + responseMessage.Body.Parts.Count; XmlDictionary dictionary = new XmlDictionary(stringCount * 2); xsiNilLocalName = dictionary.Add("nil"); xsiNilNamespace = dictionary.Add(System.Xml.Schema.XmlSchema.InstanceNamespace); OperationFormatter.GetActions(description, dictionary, out this.action, out this.replyAction); if (requestMessage.Body.WrapperName != null) { requestWrapperName = AddToDictionary(dictionary, requestMessage.Body.WrapperName); requestWrapperNamespace = AddToDictionary(dictionary, requestMessage.Body.WrapperNamespace); } requestParts = AddToDictionary(dictionary, requestMessage.Body.Parts, isRpc); if (responseMessage != null) { if (responseMessage.Body.WrapperName != null) { responseWrapperName = AddToDictionary(dictionary, responseMessage.Body.WrapperName); responseWrapperNamespace = AddToDictionary(dictionary, responseMessage.Body.WrapperNamespace); } responseParts = AddToDictionary(dictionary, responseMessage.Body.Parts, isRpc); if (responseMessage.Body.ReturnValue != null && responseMessage.Body.ReturnValue.Type != typeof(void)) { returnPart = AddToDictionary(dictionary, responseMessage.Body.ReturnValue, isRpc); } } }
// XmlWriterSettings support #endregion #region Constructors public XmlBinaryDictionaryWriter(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session, bool ownsStream) { if (dictionary == null) { dictionary = new XmlDictionary(); } if (session == null) { session = new XmlBinaryWriterSession(); } original = new MyBinaryWriter(stream); this.writer = original; buffer_writer = new MyBinaryWriter(buffer); this.dict_ext = dictionary; this.session = session; owns_stream = ownsStream; AddNamespace("xml", "http://www.w3.org/XML/1998/namespace"); AddNamespace("xml", "http://www.w3.org/2000/xmlns/"); ns_index = 2; }
public XmlSimpleDictionaryReader(XmlReader reader, XmlDictionary dictionary) : this(reader, dictionary, null) { }