void unknownNode(object sender, XmlNodeEventArgs e)
{
int n;
string[] parts;
string className, nameSpace;
if (e.ObjectBeingDeserialized != null)
{
if (!issueFound)
{
issueFound = true;
}
parts = e.ObjectBeingDeserialized.GetType().FullName.Split('.');
if ((n = parts.Length) < 2)
{
nameSpace = string.Empty;
className = parts[0];
}
else
{
nameSpace = string.Join(".", parts, 0, n - 1);
className = parts[n - 1];
}
addToNamespace(nameSpace, className, e.Name);
}
else
{
MyLogger.log(MethodBase.GetCurrentMethod(), "Found " + e.NodeType + " '" + e.Name + "' on " + e.ObjectBeingDeserialized.GetType().FullName);
}
}
void OnUnknownNode(object sender, XmlNodeEventArgs e)
{
if (e.NodeType != XmlNodeType.Comment)
{
Console.WriteLine(Res.GetString(Res.Warning, Res.GetString(Res.UnhandledNode, e.LineNumber, e.LinePosition, NodeNameOf(e))));
}
}
/// <summary>
/// Triggered when user clicks OK in Tools->Options or closes application
/// Saves the XML node to remote desktop connection manager global settings file
/// Default location "%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings"
/// </summary>
/// <returns>Node to be saved in global settings file which will be passed to PreLoad(IPluginContext,XmlNode) on next remote desktop connection manager session</returns>
public XmlNode SaveSettings()
{
XmlNodeEventArgs args = new XmlNodeEventArgs(pluginContext);
SaveSettingsEvent?.Invoke(pluginContext, args);
return(args.XmlNode);
}
private static void Serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
Debug.LogError("UnknownNode Name: " + e.Name);
Debug.LogError("UnknownNode LocalName: " + e.LocalName);
Debug.LogError("UnknownNode Namespace URI: " + e.NamespaceURI);
Debug.LogError("UnknownNode Text: " + e.Text);
}
protected void handleUnknownNode(object sender, XmlNodeEventArgs e)
{
log.write(
string.Format(
"XML_ERROR: Unknown Node at line {0} position {1} : {2}\t{3}",
e.LineNumber, e.LinePosition, e.Name, e.Text));
}
// <Snippet1>
private void serializer_UnknownNode
(object sender, XmlNodeEventArgs e)
{
XmlNodeType myNodeType = e.NodeType;
Console.WriteLine(myNodeType);
}
private static void TraceUnknownNode(XmlNodeEventArgs e)
{
_xmlParsingErrorEncountered = true;
Console.WriteLine("Unknown {0} '{1}/{2}' at L{3}/C{4}",
e.NodeType, e.NamespaceURI ?? "NONE", e.LocalName ?? "NONE", e.LineNumber, e.LinePosition);
return;
}
private void WriteWhenLastSaveHappened(object sender, EventArgs e)
{
Form mainWindowForm = (sender as IPluginContext)?.MainForm as Form;
XmlNodeEventArgs args = e as XmlNodeEventArgs;
bool updatingMainWindowText = false;
if (mainWindowForm == null || args == null)
{
return;
}
settings = args.XmlNode != null?PluginSettings.CreateSettings(args.XmlNode) : new PluginSettings();
mainWindowForm.TextChanged += (s, a) =>
{
if (!updatingMainWindowText && !string.IsNullOrWhiteSpace(settings.LastSave))
{
try
{
updatingMainWindowText = true;
mainWindowForm.Text += $" (Settings last saved {settings.LastSave})";
}
finally
{
updatingMainWindowText = false;
}
}
};
mainWindowForm.Text = string.Empty;
}
private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
if (!string.IsNullOrEmpty(e.Text))
{
Logger.Error("Unknown Node {0}", e.Name);
}
}
private void mySerializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
lock (SerializerObj)
{
m_IsHaveUnKnow = true;
}
}
private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
Log?.Invoke(this, new SerializerEventArgs()
{
Message = $"Unknown Node:{e.Name}\t{e.Text}"
});
}
/// <summary>
/// <see cref="XmlSerializer.UnknownNode"/> event handler for
/// the <see cref="XmlSerializer"/>, that raises
/// a error message box when getting an unknown node in the
/// xml settings file.
/// </summary>
/// <param name="sender">
/// Source of the event.
/// </param>
/// <param name="e">
/// A <see cref="XmlNodeEventArgs"/> that contains the event data.
/// </param>
protected void SerializerUnknownNode(object sender, XmlNodeEventArgs e)
{
string message = "Unknown Node:" + e.Name + "\t" + e.Text + Environment.NewLine + " in tracker settings file."
+ Environment.NewLine + "I try to ignore it.";
InformationDialog.Show("XML error", message, false, MessageBoxIcon.Information);
}
private void Serializer_UnknownNodeEvent(object sender, XmlNodeEventArgs e)
{
var errTxt = $"Unknown Node Name: {e.Name} LocalName: {e.LocalName} Namespace:{e.NamespaceURI} Text: {e.Text} ";
_logger.LogError(errTxt);
_errorList.Add(errTxt);
}
public XmlNodeEvent(XmlNodeEventArgs obj = null)
{
if (obj != null)
{
Data = obj;
}
}
static void OnUnknownNode(Object sender, XmlNodeEventArgs args)
{
if (args.NodeType == XmlNodeType.Attribute)
{
throw new FormatException(String.Format("Unknown XML Attribute {0}=\"{1}\"", args.Name, args.Text));
}
throw new FormatException(String.Format("Unknown XML node '{0}'", args.Name));
}
/// <summary>
/// This event is thrown if the node is not known.
/// </summary>
/// <param name="sender">The current object sender.</param>
/// <param name="e">Node event argument.</param>
void serialiser_UnknownNode(object sender, XmlNodeEventArgs e)
{
// Throw a general exception.
throw new System.Exception(
"Unknown Node : " + e.Name + " Text : " + e.Text +
"Line Number : " + e.LineNumber.ToString() +
" Line Position : " + e.LinePosition.ToString());
}
public void unknownNode(object sender, XmlNodeEventArgs e)
{
if (this.errorCount < this.maxError)
{
this.errorCount++;
this.Add(string.Format("Unexpected node found ({0}): {1} (name: {2}, namespace: {3}", this.errorCount, e.Name, e.LocalName, e.NamespaceURI));
}
}
// <Snippet1>
private void serializer_UnknownNode
(object sender, XmlNodeEventArgs e)
{
object o = e.ObjectBeingDeserialized;
Console.WriteLine("Object being deserialized: "
+ o.ToString());
}
/// <summary>
/// Handles unknown nodes in the configuration file.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The arguments of the event.</param>
/// <exception cref="InvalidConfigurationException">Thrown if an unknown node was detected in the configuration file.</exception>
private static void SerializerOnUnknownNode(object sender, XmlNodeEventArgs e)
{
if (e.LocalName == "type" && e.NodeType == XmlNodeType.Attribute)
{
return; // For some reason type definition is considered unknown
}
throw new InvalidConfigurationException(string.Format("Unknown element '{0}' found in the configuration file.", e.Name));
}
private static void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
if (e.Name == "xsi:type")
{
}
else
{
Console.WriteLine("Unknown Node:" + e.Name + "\t" + e.Text);
}
}
static void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
if (xmlAttributeErrors != null)
{
if (!xmlAttributeErrors.ContainsKey(e.Name))
{
xmlAttributeErrors[e.Name] = e.Name;
}
}
}
void foundUnknownNode(Object sender, XmlNodeEventArgs e)
{
if (e.ObjectBeingDeserialized != null)
{
MiniLogger.log(MethodBase.GetCurrentMethod(), "unhandled element: " + e.Name + " with parent " + e.ObjectBeingDeserialized.GetType().Name);
}
else
{
MiniLogger.log(MethodBase.GetCurrentMethod(), "unknown node: " + e.Name);
}
}
// ******************************************************************
private static void UnknownNode(object sender, XmlNodeEventArgs xmlNodeEventArgs)
{
// Correction according to: https://stackoverflow.com/questions/42342875/xmlserializer-warns-about-unknown-nodes-attributes-when-deserializing-derived-ty/42407193#42407193
if (xmlNodeEventArgs.Name == "xsi:type")
{
}
else
{
throw new XmlException("UnknownNode" + xmlNodeEventArgs.ToString());
}
}
public void UnknownNode(object sender, XmlNodeEventArgs e)
{
if (e.LocalName == "from" && e.ObjectBeingDeserialized.GetType() == typeof(Edge))
{
Errors.Add("Only one 'from' node is allowed in an edge.");
}
if (e.LocalName == "to" && e.ObjectBeingDeserialized.GetType() == typeof(Edge))
{
Errors.Add("Only one 'to' node is allowed in an edge.");
}
}
private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
// if the nil attribute is recognized as unknown, just skip it.
// it's the uncanny 8tracks xml syntax...
if (e.LocalName != "nil")
{
throw new SerializationException(
String.Format(
"Unknown node detected while deserializing a response at {0}:{1}. Detected node is {2}={3}.",
e.LineNumber, e.LinePosition, e.LocalName, e.Text));
}
}
private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
if (_receiveNotification != null)
{
_receiveNotification(string.Format("Ignored unknown node {0}", e.Name));
}
else
{
_msg.DebugFormat("Ignored unknown node in config file {0}: {1}",
_deserializingXmlFile, e.Name);
}
}
public void ImportErrorUnknownXMLNode(object sender, XmlNodeEventArgs e)
{
throw new Exception("Invalid XML Node:\n" +
"Line number: " + e.LineNumber +
"Line position: " + e.LinePosition +
"Local name: " + e.LocalName +
"Name: " + e.Name +
"Namespace URI: " + e.NamespaceURI +
"Node type: " + e.NodeType +
"Deserialization object: " + e.ObjectBeingDeserialized.ToString() +
"Text: " + e.Text);
}
/// <summary>
/// 存在未知节点或者位置属性时触发
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
if ("xsi:type".Equals(e.Name, StringComparison.CurrentCultureIgnoreCase))
{
return;
}
string str = string.Format("指定的XML文件中存在未知节点[{0}] 位置:[{1}]行,[{2}]列",
e.Name,
e.LineNumber,
e.LinePosition);
//Log.Info(str);
}
private void SerializerUnknownNode(object sender, XmlNodeEventArgs e)
{
STrace.Error(GetType().FullName, String.Format(
"UnknownNode, Name={0} LocalName={1} NamespaceUri={2} Text={3} NodeType={4} ObjectBeingDeserialized={5} sender={6}",
e.Name,
e.LocalName,
e.NamespaceURI,
e.Text,
e.NodeType,
e.ObjectBeingDeserialized,
sender));
}
public static void MyUnknownNodeHandler(object sender, XmlNodeEventArgs e)
{
string type = e.ObjectBeingDeserialized.GetType().ToString();
Console.WriteLine("\nUnknown node when deserializing " + type);
Console.WriteLine("Line number: " + e.LineNumber);
Console.WriteLine("Line position: " + e.LinePosition);
Console.WriteLine("Node name: " + e.Name);
Console.WriteLine("Node text: " + e.Text);
Console.WriteLine("Node type: " + e.NodeType.ToString());
Console.WriteLine("------------------------------------------------------------------");
}
private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
{
Console.WriteLine("UnknownNode Name: {0}", e.Name);
Console.WriteLine("UnknownNode LocalName: {0}", e.LocalName);
Console.WriteLine("UnknownNode Namespace URI: {0}", e.NamespaceURI);
Console.WriteLine("UnknownNode Text: {0}", e.Text);
XmlNodeType myNodeType = e.NodeType;
Console.WriteLine("NodeType: {0}", myNodeType);
Group myGroup = (Group)e.ObjectBeingDeserialized;
Console.WriteLine("GroupName: {0}", myGroup.GroupName);
Console.WriteLine();
}
private void serializer_UnknownNode
(object sender, XmlNodeEventArgs e)
{
Console.WriteLine("Unknown Node:" + e.Name + "\t" + e.Text);
}
