public XmlStream(Stream stream)
{
Stream = new LoggedStream(stream);
Stream.Logged = true;
Stream.ReadTimeout = Timeout.Infinite;
Stream.WriteTimeout = Timeout.Infinite;
_Reader = new Lazy <XmlReader>(() =>
XmlTextReader.Create(
Stream,
new XmlReaderSettings
{
CloseInput = false
}
)
);
_Writer = new Lazy <XmlWriter>(() =>
XmlWriter.Create(
Stream,
new XmlWriterSettings
{
ConformanceLevel = System.Xml.ConformanceLevel.Fragment,
OmitXmlDeclaration = true,
CloseOutput = false
}
)
);
}
private void TestDataContractSerialization(SparqlResult r, bool fullEquality)
{
Console.WriteLine("Input: " + r.ToString());
System.IO.StringWriter writer = new System.IO.StringWriter();
DataContractSerializer serializer = new DataContractSerializer(typeof(SparqlResult));
serializer.WriteObject(new XmlTextWriter(writer), r);
Console.WriteLine("Serialized Form:");
Console.WriteLine(writer.ToString());
SparqlResult s = serializer.ReadObject(XmlTextReader.Create(new StringReader(writer.ToString()))) as SparqlResult;
Console.WriteLine("Deserialized Form: " + s.ToString());
Console.WriteLine();
if (fullEquality)
{
Assert.AreEqual(r, s, "Results should be equal");
}
else
{
Assert.AreEqual(r.ToString(), s.ToString(), "String forms should be equal");
}
}
/// <summary>
/// Reads an ICalidusProject from a file
/// </summary>
/// <param name="file">The file to read from</param>
/// <returns>The calidus project</returns>
public ICalidusProject ReadFrom(String file)
{
XmlReader reader = XmlTextReader.Create(file);
CalidusProject project = (CalidusProject)ReadFrom(file, reader);
return(project);
}
private void ValidateXml(string xml)
{
try
{
// stream to validate
using (StringReader stringReader = new StringReader(xml))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessInlineSchema;
settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation;
settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
Stream stream = GetType().Assembly.GetManifestResourceStream(QuartzXsdResourceName);
XmlSchema schema = XmlSchema.Read(stream, XmlValidationCallBack);
settings.Schemas.Add(schema);
settings.ValidationEventHandler += XmlValidationCallBack;
XmlReader reader = XmlTextReader.Create(stringReader, settings);
// Read XML data
while (reader.Read())
{
}
//Close the reader.
reader.Close();
}
}
catch (Exception ex)
{
log.Warn("Unable to validate XML with schema: " + ex.Message, ex);
}
}
public void Escaping3()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<UsingTask TaskName='AssignCulture' AssemblyFile='$(MSBuildToolsPath)\net.r_eg.IeXod.Tasks.Core.dll' TaskFactory='TaskHostFactory' />
<ItemGroup>
<i Include='i1%252ai2' />
</ItemGroup>
<Target Name='Build'>
<AssignCulture Files='@(i)'>
<Output TaskParameter='AssignedFiles' ItemName='i1'/>
</AssignCulture>
<Message Text='@(i1)'/>
</Target>
</Project>
");
ProjectRootElement xml = ProjectRootElement.Create(XmlTextReader.Create(new StringReader(content)));
Project project = new Project(xml);
MockLogger logger = new MockLogger();
project.Build("Build", new ILogger[] { logger });
logger.AssertLogContains("i1%2ai2");
}
/// <summary>
/// Initializes internal properties
/// </summary>
private void InitializeReader()
{
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.IgnoreComments = true;
xmlReaderSettings.IgnoreProcessingInstructions = true;
xmlReaderSettings.IgnoreWhitespace = true;
_xmlReader = XmlTextReader.Create(_input, xmlReaderSettings);
_xmlReader.Read();
while (_xmlReader.EOF == false && _insideGpx == false)
{
if (_xmlReader.NodeType == XmlNodeType.Element)
{
if (_xmlReader.Name != "gpx")
{
throw new InvalidDataException("Invalid gpx root element. Expected <gpx>.");
}
string version = _xmlReader.GetAttribute("version");
if (version == null || (version != "1.0" && version != "1.1"))
{
throw new InvalidDataException(String.Format("Invalid version of GPX document. Expected '1.0' or '1.1' found {0}.", version));
}
_insideGpx = true;
}
else
{
_xmlReader.Read();
}
}
}
//Conversion from XML to object
public static object DeSerialize(MemoryStream msSerialized, Type outputObjectType)
{
if (msSerialized == null)
{
throw new ArgumentNullException("msSerialized");
}
if (outputObjectType == null)
{
throw new ArgumentNullException("outputObjectType");
}
object outputObject = null;
msSerialized.Seek(0, SeekOrigin.Begin);
using (XmlReader reader = XmlTextReader.Create(msSerialized))
{
if (null != reader)
{
try
{
XmlSerializer serializer = new XmlSerializer(outputObjectType);
outputObject = serializer.Deserialize(reader);
}
catch (Exception e)
{
e.ToString();
}
}
}
return(outputObject);
}
private void cmdOpen_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog opnDlg = new OpenFileDialog();
opnDlg.Filter = "Alle Unterstützten Datentypen (*.wpfvartab)|*.wpfvartab";
var retVal = opnDlg.ShowDialog();
if (retVal == true)
{
varTabRows.Clear();
System.IO.FileStream jj = new FileStream(opnDlg.FileName, FileMode.Open);
var settings = new XmlReaderSettings()
{
CheckCharacters = false
};
var read = XmlTextReader.Create(jj, settings);
System.Xml.Serialization.XmlSerializer myXml = new XmlSerializer(typeof(ObservableCollection <VarTabRowWithConnection>));
var saved = (ObservableCollection <VarTabRowWithConnection>)myXml.Deserialize(read);
foreach (var varTabRowWithConnection in saved)
{
varTabRows.Add(varTabRowWithConnection);
}
jj.Close();
}
}
protected FilterData(SerializationInfo info, StreamingContext context)
{
string s = (string)info.GetValue("XmlSchema", typeof(string));
if (s != null)
{
DataSet dataSet = new DataSet();
dataSet.ReadXmlSchema(XmlTextReader.Create(new StringReader(s), new XmlReaderSettings()
{
DtdProcessing = DtdProcessing.Ignore, XmlResolver = null
}));
if (dataSet.Tables["Filters"] != null)
{
base.Tables.Add(new FiltersDataTable(dataSet.Tables["Filters"]));
}
base.DataSetName = dataSet.DataSetName;
base.Prefix = dataSet.Prefix;
base.Namespace = dataSet.Namespace;
base.Locale = dataSet.Locale;
base.CaseSensitive = dataSet.CaseSensitive;
base.EnforceConstraints = dataSet.EnforceConstraints;
base.Merge(dataSet, false, MissingSchemaAction.Add);
this.InitVars();
}
else
{
this.InitClass();
}
base.GetSerializationData(info, context);
CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += handler;
base.Relations.CollectionChanged += handler;
}
public XmlReader Open()
{
Stream stream;
if (!string.IsNullOrEmpty(file))
{
stream = File.OpenRead(Addin.GetFilePath(file));
}
else if (!string.IsNullOrEmpty(resource))
{
stream = Addin.GetResource(resource);
if (stream == null)
{
throw new ApplicationException("Template " + resource + " not found");
}
}
else
{
throw new InvalidOperationException("Template file or resource not provided");
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.CloseInput = true;
return(XmlTextReader.Create(stream, settings));
}
public static Properties Load(string fileName)
{
if (!File.Exists(fileName))
{
return(null);
}
XmlReader reader = XmlTextReader.Create(fileName);
try {
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case PropertiesRootNode:
if (reader.GetAttribute(PropertiesVersionAttribute) == PropertiesVersion)
{
return(Read(reader));
}
break;
}
}
}
} finally {
reader.Close();
}
return(null);
}
private static IEnumerable <XmlNode> BuildTree(string xmlString, out CDataMatchHandler cdataMatchHandler)
{
cdataMatchHandler = new CDataMatchHandler();
xmlString = _encodeCDataRegex.Replace(xmlString, cdataMatchHandler.Encode);
xmlString = _encodeRegex.Replace(xmlString, delegate(Match match)
{
string entiryStr = match.Groups["tag"].Value;
return(IsCorrectEscapeEntity(entiryStr)
? _ampersandWord + entiryStr
: "&" + entiryStr);
});
var xmlReaderSettings = new XmlReaderSettings {
DtdProcessing = DtdProcessing.Parse, XmlResolver = null
};
using (XmlReader xmlReader = XmlTextReader.Create(new StringReader(xmlString), xmlReaderSettings))
{
return(BuildTree(xmlReader, 0).ToList());
}
}
/// <summary>
/// Parsing del contenuto in formato xml dell'oggetto "DocumentoRequest"
/// </summary>
/// <param name="requestXml"></param>
/// <returns></returns>
public static DocumentoRequest Parse(string requestXml)
{
DocumentoRequest request = new DocumentoRequest();
using (MemoryStream stream = new MemoryStream(System.Text.Encoding.Default.GetBytes(requestXml)))
{
XmlReader reader = XmlTextReader.Create(stream);
while (reader.Read())
{
if (reader.IsStartElement("documento"))
{
request.numDocumento = MoveToAndGetAttributeValue(reader, "num");
}
else if (reader.IsStartElement("userInfo"))
{
request.UserInfo = new DocsPaVO.utente.InfoUtente();
request.UserInfo.userId = MoveToAndGetAttributeValue(reader, "userId");
request.UserInfo.idCorrGlobali = MoveToAndGetAttributeValue(reader, "idCorrGlobali");
request.UserInfo.idPeople = MoveToAndGetAttributeValue(reader, "idPeople");
request.UserInfo.idGruppo = MoveToAndGetAttributeValue(reader, "idGruppo");
request.UserInfo.idAmministrazione = MoveToAndGetAttributeValue(reader, "idAmministrazione");
request.UserInfo.sede = MoveToAndGetAttributeValue(reader, "sede");
request.UserInfo.urlWA = MoveToAndGetAttributeValue(reader, "urlWA");
request.UserInfo.dst = MoveToAndGetAttributeValue(reader, "dst");
}
}
}
return(request);
}
protected override void Open()
{
if (_xpath == null)
{
_xmlReader = _stream != null?
XmlTextReader.Create(_stream, _settings) :
XmlTextReader.Create(_url, _settings);
}
else
{
var xpaths = new XPathCollection();
xpaths.Add(_xpath);
var inner = _stream != null ?
new XmlTextReader(_stream) :
new XmlTextReader(_url);
inner.Namespaces = !_ignoreNamespaces;
if (_settings != null)
{
// TODO: map more XmlReaderSettings to XmlTextReader properties (check in reflector)
if (_settings.IgnoreWhitespace)
{
inner.WhitespaceHandling = WhitespaceHandling.None;
}
inner.DtdProcessing = _settings.DtdProcessing;
}
_xmlReader = new XPathReader(inner, xpaths);
}
}
public static WindowsTemplateBodyType DetectWindowsTemplateRegistationType(string body, string errorMsg)
{
XmlDocument xmlPayload = new XmlDocument();
using (var reader = XmlTextReader.Create(new StringReader(body)))
{
try
{
xmlPayload.Load(reader);
}
catch (XmlException)
{
throw new ArgumentException(errorMsg);
}
XmlNode node = xmlPayload.FirstChild;
while (node != null && node.NodeType != XmlNodeType.Element)
{
node = node.NextSibling;
}
if (node == null)
{
throw new ArgumentException(errorMsg);
}
WindowsTemplateBodyType registrationType;
if (node == null || !Enum.TryParse(node.Name, true, out registrationType))
{
throw new ArgumentException(errorMsg);
}
return(registrationType);
}
}
private void SaveTypeSynonim(type_synonym ctn)
{
if (!string.IsNullOrEmpty(ctn.documentation))
{
if (!ctn.documentation.Trim(' ', '\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
xtw.WriteString("T:" + ctn.name);
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(ctn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\"" + "T:" + ctn.name + "\">", ctn.documentation, "</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(), false);
sr.Close();
xr.Close();
}
}
}
static void Main(string[] args)
{
XmlReader reader = XmlTextReader.Create(new StringReader(InstanceDocument));
ThreadedFeed feed = SyndicationFeed.Load <ThreadedFeed>(reader);
foreach (ThreadedItem i in feed.ThreadedItems)
{
//ThreadedItem exposes a strongly-typed member called InReplyTo
//holding the extension data.
Console.WriteLine(i.InReplyTo.ToString());
}
Console.WriteLine("");
Atom10FeedFormatter formatter = feed.GetAtom10Formatter();
XmlWriter writer = XmlTextWriter.Create(Console.Out, new XmlWriterSettings()
{
Indent = true
});
formatter.WriteTo(writer);
writer.Flush();
Console.ReadLine();
}
private void SaveFunction(common_namespace_function_node cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ', '\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
xtw.WriteString("M:" + (is_assembly?unit_name + "." + unit_name + ".":"") + cfn.name + GetGenericFlag(cfn) + GetParameters(cfn));
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\"" + "M:" + (is_assembly?unit_name + "." + unit_name + ".":"") + cfn.name + GetGenericFlag(cfn) + GetParameters(cfn) + "\">", cfn.documentation, "</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(), false);
sr.Close();
xr.Close();
}
}
}
public void Setup()
{
XmlReader xr = XmlTextReader.Create(TestResourceHelper.GetFullPathOfResource("Test/Resources/one.xml"));
metadata = MetadataSet.ReadFrom(xr);
NewXmlSchemaSet();
}
private void SaveClassConstant(class_constant_definition cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ', '\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
if (is_assembly)
{
xtw.WriteString("F:" + get_name(cfn.comperehensive_type) + "." + cfn.name);
}
else
{
xtw.WriteString("F:" + cfn.comperehensive_type.name + "." + cfn.name);
}
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\"" + (is_assembly?("F:" + get_name(cfn.comperehensive_type) + "." + cfn.name):("F:" + cfn.comperehensive_type.name + "." + cfn.name)) + "\">", cfn.documentation, "</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(), false);
sr.Close();
xr.Close();
}
}
}
protected FileData(SerializationInfo info, StreamingContext context)
{
string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
if ((strSchema != null))
{
DataSet ds = new DataSet();
ds.ReadXmlSchema(XmlTextReader.Create(new System.IO.StringReader(strSchema), new XmlReaderSettings()
{
DtdProcessing = DtdProcessing.Ignore, XmlResolver = null
}));
if ((ds.Tables["Files"] != null))
{
this.Tables.Add(new FilesDataTable(ds.Tables["Files"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else
{
this.InitClass();
}
this.GetSerializationData(info, context);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
this.Tables.CollectionChanged += schemaChangedHandler;
this.Relations.CollectionChanged += schemaChangedHandler;
}
private void SaveVariable(var_definition_node cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ', '\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
if (!is_assembly)
{
xtw.WriteString("V:" + cfn.name);
}
else
{
xtw.WriteString("F:" + unit_name + "." + unit_name + "." + cfn.name);
}
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\"" + (is_assembly?"F:" + unit_name + "." + unit_name + ".":"V:") + cfn.name + "\">", cfn.documentation, "</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(), false);
sr.Close();
xr.Close();
}
}
}
public static T Load(string xamlContainingString)
{
StringReader stringReader = new StringReader(xamlContainingString);
XmlReader xmlReader = XmlTextReader.Create(stringReader, new XmlReaderSettings());
return(Load(xmlReader));
}
public void load(String path)
{
System.IO.StreamReader file = new System.IO.StreamReader(path);
// Create an XmlReaderSettings object.
XmlReaderSettings settings = new XmlReaderSettings();
// Set XmlResolver to null, and ProhibitDtd to false.
settings.XmlResolver = null;
settings.DtdProcessing = DtdProcessing.Ignore;
// Now, create an XmlReader. This is a forward-only text-reader based
// reader of Xml. Passing in the settings will ensure that validation
// is not performed.
XmlReader reader = XmlTextReader.Create(file, settings);
// Create your document, and load the reader.
XmlDocument doc = new XmlDocument();
doc.Load(reader);
XmlNode root = doc.DocumentElement.FirstChild;
Dictionary <string, XmlNode> dict = tree_to_dict(root);
plistFile = dict_to_plist(dict);
file.Close();
}
private void TestSerializationDataContract(INode n, Type t, bool fullEquality)
{
Console.WriteLine("Input: " + n.ToString());
System.IO.StringWriter writer = new System.IO.StringWriter();
DataContractSerializer serializer = new DataContractSerializer(t);
serializer.WriteObject(new XmlTextWriter(writer), n);
Console.WriteLine("Serialized Form:");
Console.WriteLine(writer.ToString());
INode m = serializer.ReadObject(XmlTextReader.Create(new StringReader(writer.ToString()))) as INode;
Console.WriteLine("Deserialized Form: " + m.ToString());
Console.WriteLine();
if (fullEquality)
{
Assert.AreEqual(n, m, "Nodes should be equal");
}
else
{
Assert.AreEqual(n.ToString(), m.ToString(), "String forms should be equal");
}
}
static List <ExternalTool> LoadTools(string fileName)
{
if (!File.Exists(fileName))
{
return(null);
}
List <ExternalTool> result = new List <ExternalTool> ();
XmlReader reader = XmlTextReader.Create(fileName);
try {
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case Node:
string fileVersion = reader.GetAttribute(VersionAttribute);
if (fileVersion != Version)
{
return(null);
}
break;
case ExternalTool.Node:
result.Add(ExternalTool.Read(reader));
break;
}
}
}
} finally {
reader.Close();
}
return(result);
}
public XmlReader CreateReader(Stream stream, string baseUri)
{
XmlReader reader;
if (_xmlReaderSettings != null)
{
reader = XmlTextReader.Create(stream, _xmlReaderSettings, baseUri);
}
else
{
XmlTextReaderImpl readerImpl = new XmlTextReaderImpl(baseUri, stream, _xmlNameTable !);
readerImpl.EntityHandling = _entityHandling;
readerImpl.Namespaces = _namespaces;
readerImpl.Normalization = _normalization;
readerImpl.DtdProcessing = _prohibitDtd ? DtdProcessing.Prohibit : DtdProcessing.Parse;
readerImpl.WhitespaceHandling = _whitespaceHandling;
readerImpl.XmlResolver = _xmlResolver;
reader = readerImpl;
}
if (_validatingReader)
{
#pragma warning disable 618
reader = new XmlValidatingReader(reader);
#pragma warning restore 618
}
return(reader);
}
void NoExtensionsSetup()
{
XmlReaderSettings xs = new XmlReaderSettings();
xs.IgnoreWhitespace = true;
xtr = XmlTextReader.Create("Test/System.ServiceModel.Description/dump.xml", xs);
xtr.Read();
//FIXME: skipping Headers
while (xtr.LocalName != "Body")
{
if (!xtr.Read())
{
return;
}
}
//Move to <Metadata ..
xtr.Read();
ms = MetadataSet.ReadFrom(xtr);
//MyWsdlImportExtension mw = new MyWsdlImportExtension ();
List <IWsdlImportExtension> list = new List <IWsdlImportExtension> ();
//list.Add (mw);
list.Add(new DataContractSerializerMessageContractImporter());
/*list.Add (new MessageEncodingBindingElementImporter ());
* list.Add (new TransportBindingElementImporter ());
* list.Add (new StandardBindingImporter ());*/
wi = new WsdlImporter(ms, null, list);
}
// determine whether a given file is supported based on the
// root element
private bool IsFileSupported(string nativeFilePath)
{
bool result = false;
bool isTmx = false;
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = null;
settings.DtdProcessing = DtdProcessing.Ignore;
XmlReader xmlReader = XmlTextReader.Create(nativeFilePath, settings);
XmlDocument doc = new XmlDocument();
doc.Load(xmlReader);
if (doc.DocumentElement.Name == _BilingualDocument)
{
isTmx = true;
}
if (isTmx)
{
result = true;
}
return(result);
}
private EAS.generated.SyncResponseNamespace.Sync GetSyncObjectFromXML(string x)
{
try
{
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings()
{
CheckCharacters = false
};
XmlReader xmlReader = XmlTextReader.Create(new StringReader(x), xmlReaderSettings);
XmlSerializer deser = new XmlSerializer(typeof(EAS.generated.SyncResponseNamespace.Sync));
EAS.generated.SyncResponseNamespace.Sync sync = (EAS.generated.SyncResponseNamespace.Sync)deser.Deserialize(xmlReader);
//SyncCollectionsCollectionResponsesFetchApplicationData
//[System.Xml.Serialization.XmlElementAttribute("Attachments", typeof(Attachments[]), Namespace = "AirSyncBase")] //ZMIANA Z Attachments na Attachments[]
return(sync);
}
catch (Exception ex)
{
List <string> lstError = new List <string>();
lstError.Add(ex.Message);
lstError.Add(x);
File.WriteAllLines(mailDir + "\\" + DateTime.Now.Ticks + ".txt", lstError);
return(null);
}
}
