static void Main(string[] args)
{
try
{
XmlContainer container = new XmlContainer("Objects.xml");
AlbumLister lister = container.GetObject("AlbumLister") as AlbumLister;
string response = "";
while (response != "x")
{
Console.Write("Enter an artist: ");
IEnumerable<Album> albums = lister.FindByArtist(Console.ReadLine());
foreach (Album album in albums)
{
Console.WriteLine(album.Title);
}
Console.Write("\r\nPress any key to continue or type x to quit: ");
response = Console.ReadLine();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.GetBaseException().Message);
}
}
/// <summary>
/// Determines whether the specified message contains tag under the parentTag.
/// </summary>
public static bool ContainsTag(this XmlContainer message, String parentTag, String tag)
{
if (String.IsNullOrEmpty(parentTag))
{
throw new ArgumentException("parentTag");
}
if (String.IsNullOrEmpty(tag))
{
throw new ArgumentException("tag");
}
try
{
XElement doc = XElement.Parse(message.GetXmlString(XmlNamespaceOption.IgnoreNamespaces));
var parentElement = doc.GetElementWithName(parentTag);
return(null != parentElement && null != parentElement.GetElementWithName(tag));
}
catch (XmlException e)
{
Logger.LogException(String.Empty, e);
return(false);
}
}
public override bool ApplyWorker(XmlDocument xml)
{
bool flag = false;
bool result;
if (this.defName.NullOrEmpty() && this.Name.NullOrEmpty())
{
result = false;
}
else
{
string search = this.defName.NullOrEmpty() ? "@Name" : "defName";
string s = this.defName.NullOrEmpty() ? this.Name : this.defName;
foreach (object obj in xml.SelectNodes("Defs/ThingDef[" + search + "=\"" + s + "\"]"))
{
flag = true;
XmlNode xmlNode = obj as XmlNode;
// Log.Message("Original: "+xmlNode.OuterXml.ToString());
this.SetAttributes(xmlNode, "Class", defClass);
if (!thingClass.NullOrEmpty())
{
this.AddOrReplaceThingClass(xml, xmlNode);
}
XmlContainer xmlContainer = this.projectile;
bool flag3 = xmlContainer != null && xmlContainer.node.HasChildNodes;
if (flag3)
{
this.ReplaceProjectileProps(xml, xmlNode);
}
// Log.Message("Modified: " + xmlNode.OuterXml.ToString());
}
result = flag;
}
return(result);
}
public Form1()
{
InitializeComponent();
logicLayer = new PodcastMani();
_xmlcontainer = new XmlContainer();
_categories = _xmlcontainer.GetAllCatergories();
FillCatergory();
}
internal static Container Create(XmlContainer v)
{
if (v == null)
{
return(null);
}
return(new Container(v));
}
// Token: 0x060000F2 RID: 242 RVA: 0x0000AA98 File Offset: 0x00008C98
protected override bool ApplyWorker(XmlDocument xml)
{
bool flag = false;
bool flag2 = GenText.NullOrEmpty(this.defName);
bool result;
if (flag2)
{
result = false;
}
else
{
foreach (object obj in xml.SelectNodes("Defs/ThingDef[defName=\"" + this.defName + "\"]"))
{
flag = true;
XmlNode xmlNode = obj as XmlNode;
XmlContainer xmlContainer = this.statBases;
bool flag3 = xmlContainer != null && xmlContainer.node.HasChildNodes;
if (flag3)
{
this.AddOrReplaceStatBases(xml, xmlNode);
}
XmlContainer xmlContainer2 = this.costList;
bool flag4 = xmlContainer2 != null && xmlContainer2.node.HasChildNodes;
if (flag4)
{
this.AddOrReplaceCostList(xml, xmlNode);
}
bool flag5 = this.Properties != null && this.Properties.node.HasChildNodes;
if (flag5)
{
this.AddOrReplaceVerbPropertiesCE(xml, xmlNode);
}
bool flag6 = this.AmmoUser != null || this.FireModes != null;
if (flag6)
{
this.AddOrReplaceCompsCE(xml, xmlNode);
}
bool flag7 = this.weaponTags != null && this.weaponTags.node.HasChildNodes;
if (flag7)
{
this.AddOrReplaceWeaponTags(xml, xmlNode);
}
bool flag8 = this.researchPrerequisite != null;
if (flag8)
{
this.AddOrReplaceResearchPrereq(xml, xmlNode);
}
bool flag9 = ModLister.HasActiveModWithName("RunAndGun") && !this.AllowWithRunAndGun;
if (flag9)
{
this.AddRunAndGunExtension(xml, xmlNode);
}
}
result = flag;
}
return(result);
}
/// <summary>
/// Save Content
/// </summary>
/// <typeparam name="T">Text Content Type</typeparam>
/// <param name="content">Content</param>
private void Save <T>(string content)
where T : TextContent
{
var container = new XmlContainer <T>(ServerConfiguration.Default);
var blogPost = Activator.CreateInstance <T>();
blogPost.Content = content;
blogPost.CreatedOn = DateTime.UtcNow;
blogPost.Active = true;
blogPost.Deleted = false;
blogPost.Id = Guid.NewGuid();
container.Save(blogPost.Id.ToString(), blogPost);
}
/// <summary>
/// /// Returns true if message contains tag under the parent tag
/// </summary>
public static bool ContainsTag(XmlContainer message, String tag)
{
if (null == message)
{
throw new ArgumentNullException();
}
if (String.IsNullOrEmpty(tag))
{
throw new ArgumentException();
}
return(message.ContainsTag(tag));
}
/// <summary>
/// Returns value of given tag in given message, null otherwise
/// </summary>
public static String ValueOf(XmlContainer message, String tag)
{
if (null == message)
{
throw new ArgumentNullException();
}
if (String.IsNullOrEmpty(tag))
{
throw new ArgumentException();
}
XElement doc = XElement.Parse(message.GetXmlString(XmlNamespaceOption.IgnoreNamespaces));
var element = doc.GetElementWithName(tag);
return(null == element ? null : element.Value);
}
/// <summary>
/// Returns attributes of given tag in given message, null otherwise
/// </summary>
public static XAttribute[] AttributesOf(XmlContainer message, String tag)
{
if (null == message)
{
throw new ArgumentNullException();
}
if (String.IsNullOrEmpty(tag))
{
throw new ArgumentException();
}
XElement doc = XElement.Parse(message.GetXmlString(XmlNamespaceOption.IgnoreNamespaces));
var element = doc.Descendants().FirstOrDefault(item => item.Name.LocalName == tag);
return(null == element ? null : element.Attributes().ToArray());
}
// Token: 0x060000F2 RID: 242 RVA: 0x0000979C File Offset: 0x0000799C
protected override bool ApplyWorker(XmlDocument xml)
{
bool result = false;
if (GenText.NullOrEmpty(this.defName))
{
return(false);
}
foreach (object obj in xml.SelectNodes("*/ThingDef[defName=\"" + this.defName + "\"]"))
{
result = true;
XmlNode xmlNode = obj as XmlNode;
XmlContainer xmlContainer = this.statBases;
if (xmlContainer != null && xmlContainer.node.HasChildNodes)
{
this.AddOrReplaceStatBases(xml, xmlNode);
}
XmlContainer xmlContainer2 = this.costList;
if (xmlContainer2 != null && xmlContainer2.node.HasChildNodes)
{
this.AddOrReplaceCostList(xml, xmlNode);
}
if (this.Properties != null && this.Properties.node.HasChildNodes)
{
this.AddOrReplaceVerbPropertiesCE(xml, xmlNode);
}
if (this.AmmoUser != null || this.FireModes != null)
{
this.AddOrReplaceCompsCE(xml, xmlNode);
}
if (this.weaponTags != null && this.weaponTags.node.HasChildNodes)
{
this.AddOrReplaceWeaponTags(xml, xmlNode);
}
if (this.researchPrerequisite != null)
{
this.AddOrReplaceResearchPrereq(xml, xmlNode);
}
}
return(result);
}
public void SaveGet()
{
Random random = new Random();
TextContainer <EntityWithDataStore> container = new XmlContainer <EntityWithDataStore>(CloudStorageAccount.DevelopmentStorageAccount);
container.EnsureExist();
var entity = new EntityWithDataStore()
{
PartitionKey = Guid.NewGuid().ToBase64(),
RowKey = Guid.NewGuid().ToAscii85(),
ToTest = random.Next()
};
var id = Guid.NewGuid().ToString();
container.Save(id, entity);
var returned = container.Get(id);
Assert.IsNotNull(returned);
Assert.AreEqual <string>(entity.PartitionKey, returned.PartitionKey);
Assert.AreEqual <string>(entity.RowKey, returned.RowKey);
Assert.AreEqual <int>(entity.ToTest, returned.ToTest);
}
static void Main(string[] args)
{
string outputType = "unassigned";
string path = "unassigned";
int recordsAmount = 0;
int startId = 0;
try
{
if (args.Length >= 1)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i].Contains("--output-type", StringComparison.InvariantCultureIgnoreCase))
{
var argsArr = args[i].Split('=');
outputType = argsArr[1];
}
if (args[i].Contains("--output", StringComparison.InvariantCultureIgnoreCase))
{
var argsArr = args[i].Split('=');
path = argsArr[1];
}
if (args[i].Contains("--records-amount", StringComparison.InvariantCultureIgnoreCase))
{
var argsArr = args[i].Split('=');
if (!Int32.TryParse(argsArr[1], out recordsAmount))
{
throw new ArgumentException($"Incorrect records amount: {argsArr[1]}");
}
if (recordsAmount <= 0)
{
throw new ArgumentOutOfRangeException($"Records amount is less or equal to zero.");
}
}
if (args[i].Contains("--start-id", StringComparison.InvariantCultureIgnoreCase))
{
var argsArr = args[i].Split('=');
if (!Int32.TryParse(argsArr[1], out startId))
{
throw new ArgumentException($"Incorrect start ID: {argsArr[1]}");
}
if (startId < 0)
{
throw new ArgumentOutOfRangeException($"Start ID is less than zero.");
}
}
if (args[i].Equals("-t", StringComparison.InvariantCultureIgnoreCase))
{
i++;
outputType = args[i];
}
if (args[i].Equals("-o", StringComparison.InvariantCultureIgnoreCase))
{
i++;
path = args[i];
}
if (args[i].Equals("-a", StringComparison.InvariantCultureIgnoreCase))
{
i++;
if (!Int32.TryParse(args[i], out recordsAmount))
{
throw new ArgumentException($"Incorrect records amount: {args[i]}");
}
if (recordsAmount <= 0)
{
throw new ArgumentOutOfRangeException($"Records amount is less or equal to zero.");
}
}
if (args[i].Equals("-i", StringComparison.InvariantCultureIgnoreCase))
{
i++;
if (!Int32.TryParse(args[i], out startId))
{
throw new ArgumentException($"Incorrect start ID: {args[i]}");
}
if (startId < 0)
{
throw new ArgumentOutOfRangeException($"Start ID is less than zero.");
}
}
}
}
if (File.Exists(path))
{
while (true)
{
Console.Write($"File is exist - rewrite {path} [Y/n] ");
string answer = Console.ReadKey().KeyChar.ToString(CultureInfo.InvariantCulture);
Console.WriteLine();
if (answer.Equals("y", StringComparison.InvariantCultureIgnoreCase))
{
break;
}
if (answer.Equals("n", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
}
}
switch (outputType)
{
case "csv":
using (StreamWriter sw = new StreamWriter(new FileStream(path, FileMode.Create)))
{
new CSVWriter(sw).Generate(RecordGenerator.Generate(recordsAmount, startId));
}
Console.WriteLine($"{recordsAmount} records were written to {path}");
break;
case "xml":
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
XmlContainer container = new XmlContainer
{
Records = RecordGenerator.Generate(recordsAmount, startId)
};
new XMLWriter(fs).Generate(container);
}
Console.WriteLine($"{recordsAmount} records were written to {path}");
break;
default:
throw new ArgumentException($"Incorrect output type: {outputType}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
// Use this for initialization
void Awake()
{
instance = this;
Full_Dance = parseFile("Basic");
}
private Container(XmlContainer c)
{
this.cont_ = c;
}
public void Generate(XmlContainer container)
{
serializer.Serialize(fs, container);
}
