/// <summary>
/// Parses a well-formed XAML fragment and creates a corresponding Silverlight object tree,
/// and returns the root of the object tree.
/// </summary>
/// <returns>The root object of the Silverlight object tree.</returns>
/// <param name="xaml">A string that contains a valid XAML fragment.</param>
public static object Load(string xaml)
{
var textReader = new StringReader(xaml);
var xamlReader = new XamlXmlReader(textReader);
var xamlWriter = new XamlObjectWriter(xamlReader.SchemaContext);
if (xamlReader.NodeType == XamlNodeType.None)
{
xamlReader.Read();
}
var xamlLineInfo = xamlReader as IXamlLineInfo;
var xamlLineConsumer = xamlWriter as IXamlLineInfoConsumer;
var shouldSetLineInfo = xamlLineInfo != null && xamlLineConsumer != null && xamlLineConsumer.ShouldProvideLineInfo && xamlLineInfo.HasLineInfo;
while (!xamlReader.IsEof)
{
if (shouldSetLineInfo)
{
xamlLineConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition);
}
xamlWriter.WriteNode(xamlReader);
xamlReader.Read();
}
return(xamlWriter.Result);
}
public static void GetNamespacesLineInfo(string sourceXamlFileName, Dictionary <string, int> lineNumbersForNSes, Dictionary <string, int> lineNumbersForNSesForImpl)
{
// read until StartMember: TextExpression.NamespacesForImplementation OR TextExpression.Namespaces
// create a subtree reader,
// in the subtree,
// look for StartObject nodes of String type. their values are added to either LineNumbersForNSes or LineNumbersForNSesForImpl dictionaries.
if (!File.Exists(sourceXamlFileName))
{
return;
}
using (XmlReader xmlReader = XmlReader.Create(sourceXamlFileName, new XmlReaderSettings {
XmlResolver = null
}))
{
using (XamlXmlReader xreader = new XamlXmlReader(xmlReader, new XamlXmlReaderSettings()
{
ProvideLineInfo = true
}))
{
bool hasHitFirstStartObj = false;
while (!hasHitFirstStartObj && xreader.Read())
{
if (xreader.NodeType == XamlNodeType.StartObject)
{
hasHitFirstStartObj = true;
}
}
if (hasHitFirstStartObj)
{
xreader.Read();
do
{
if (IsStartMemberTextExprNS(xreader))
{
XamlReader subTreeReader = xreader.ReadSubtree();
WalkSubTree(subTreeReader, lineNumbersForNSes);
}
else if (IsStartMemberTextExprNSForImpl(xreader))
{
XamlReader subTreeReader = xreader.ReadSubtree();
WalkSubTree(subTreeReader, lineNumbersForNSesForImpl);
}
else
{
xreader.Skip();
}
}while (!xreader.IsEof);
}
}
}
}
public XamlFileDefinition Parse(string content)
{
var document = XmlReader.Create(new StringReader(content));
// Initialize the reader using an empty context, because when the tasl
// is run under the BeforeCompile in VS IDE, the loaded assemblies are used
// to interpret the meaning of objects, which is not correct in Uno.UI context.
var context = new XamlSchemaContext(Enumerable.Empty <Assembly>());
// Force the line info, otherwise it will be enabled only when the debugger is attached.
var settings = new XamlXmlReaderSettings()
{
ProvideLineInfo = true
};
using (var reader = new XamlXmlReader(document, context, settings))
{
if (reader.Read())
{
return(Visit(reader));
}
}
return(null);
}
XamlType GetRootXamlType()
{
try
{
using (Stream xamlStream = base.OpenStream())
{
XmlReader xmlReader = XmlReader.Create(xamlStream);
XamlXmlReader xamlReader = new XamlXmlReader(xmlReader);
// Read to the root object
while (xamlReader.Read())
{
if (xamlReader.NodeType == XamlNodeType.StartObject)
{
return(xamlReader.Type);
}
}
throw FxTrace.Exception.AsError(new HttpCompileException(SR.UnexpectedEof));
}
}
catch (XamlParseException ex)
{
throw FxTrace.Exception.AsError(new HttpCompileException(ex.Message, ex));
}
}
private XamlFileDefinition Visit(XamlXmlReader reader, string file)
{
WriteState(reader);
var xamlFile = new XamlFileDefinition(file);
do
{
switch (reader.NodeType)
{
case XamlNodeType.StartObject:
_depth++;
xamlFile.Objects.Add(VisitObject(reader, null));
break;
case XamlNodeType.NamespaceDeclaration:
xamlFile.Namespaces.Add(reader.Namespace);
break;
default:
throw new InvalidOperationException();
}
}while (reader.Read());
return(xamlFile);
}
private void Visit(XamlXmlReader reader, XamlObjectDefinition xamlObject)
{
while (reader.Read())
{
WriteState(reader);
switch (reader.NodeType)
{
case XamlNodeType.StartMember:
_depth++;
xamlObject.Members.Add(VisitMember(reader, xamlObject));
break;
case XamlNodeType.StartObject:
_depth++;
xamlObject.Objects.Add(VisitObject(reader, xamlObject));
break;
case XamlNodeType.Value:
xamlObject.Value = reader.Value;
break;
case XamlNodeType.EndObject:
_depth--;
return;
case XamlNodeType.EndMember:
_depth--;
break;
default:
throw new InvalidOperationException();
}
}
}
public void TestBaseUri2()
{
string xaml = @"
<c:ArrayList xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
xmlns:s='clr-namespace:System;assembly=mscorlib'
xmlns:c='clr-namespace:System.Collections;assembly=mscorlib' xml:base='http://schemas.microsoft.com/winfx/2006/xaml'>
<s:String>Hello</s:String>
</c:ArrayList>";
MemoryStream ms = new MemoryStream();
using (StreamWriter sw = new StreamWriter(ms))
{
sw.Write(xaml);
sw.Flush();
ms.Position = 0;
XamlXmlReaderSettings settings = new XamlXmlReaderSettings();
XamlXmlReader xxr = new XamlXmlReader(ms, settings);
XamlObjectWriter objWriter = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
{
objWriter.WriteNode(xxr);
}
objWriter.Clear();
objWriter.Close();
}
}
public static void Load(Stream stream, object component)
{
DependencyObject dependencyObject = component as DependencyObject;
NameScope nameScope = new NameScope();
if (dependencyObject != null)
{
NameScope.SetNameScope(dependencyObject, nameScope);
}
XmlReader xml = XmlReader.Create(stream);
XamlXmlReader reader = new XamlXmlReader(xml);
XamlObjectWriter writer = new XamlObjectWriter(
new XamlSchemaContext(),
new XamlObjectWriterSettings
{
RootObjectInstance = component,
ExternalNameScope = nameScope,
RegisterNamesOnExternalNamescope = true,
XamlSetValueHandler = SetValue,
});
while (reader.Read())
{
writer.WriteNode(reader);
}
}
private XamlFileDefinition ParseFile(string file)
{
try
{
this.Log().InfoFormat("Pre-processing XAML file: {0}", file);
var document = ApplyIgnorables(file);
// Initialize the reader using an empty context, because when the tasl
// is run under the BeforeCompile in VS IDE, the loaded assemblies are used
// to interpret the meaning of objects, which is not correct in Uno.UI context.
var context = new XamlSchemaContext(Enumerable.Empty <Assembly>());
// Force the line info, otherwise it will be enabled only when the debugger is attached.
var settings = new XamlXmlReaderSettings()
{
ProvideLineInfo = true
};
using (var reader = new XamlXmlReader(document, context, settings))
{
if (reader.Read())
{
return(Visit(reader, file));
}
}
return(null);
}
catch (Exception e)
{
throw new InvalidOperationException($"Failed to parse file {file}", e);
}
}
public override Type GetGeneratedType(CompilerResults results)
{
Type type;
try
{
using (Stream stream = base.OpenStream())
{
XamlXmlReader reader2 = new XamlXmlReader(XmlReader.Create(stream));
while (reader2.Read())
{
if (reader2.NodeType == XamlNodeType.StartObject)
{
if (reader2.Type.IsUnknown)
{
StringBuilder sb = new StringBuilder();
this.AppendTypeName(reader2.Type, sb);
throw FxTrace.Exception.AsError(new TypeLoadException(System.Xaml.Hosting.SR.CouldNotResolveType(sb)));
}
return(reader2.Type.UnderlyingType);
}
}
throw FxTrace.Exception.AsError(new HttpCompileException(System.Xaml.Hosting.SR.UnexpectedEof));
}
}
catch (XamlParseException exception)
{
throw FxTrace.Exception.AsError(new HttpCompileException(exception.Message, exception));
}
return(type);
}
private void LoadWorkspace(string workspaceFile)
{
try
{
using (XamlXmlReader reader = new XamlXmlReader(workspaceFile))
{
using (XamlObjectWriter writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
Workspace = (MdiDemoWorkspace)writer.Result;
_workspaceFile = workspaceFile;
}
}
GC.Collect(); // lame! The XamlXmlReader will leave the file open until the next GC.
GC.WaitForPendingFinalizers();
}
catch (Exception)
{
MessageBox.Show(String.Format("An error occured opening MDI workspace file '{0}'.", workspaceFile));
}
}
private UIElement Load(string path)
{
using (var reader = new XamlXmlReader(path))
using (var writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
return((UIElement)writer.Result);
}
}
protected override void Write(XamlMarkdownWriter renderer, HtmlEntityInline obj)
{
var txt = obj.Transcoded.Text.Substring(obj.Transcoded.Start, obj.Transcoded.Length);
using (var xaml = new XamlXmlReader(new StringReader(txt), new XamlXmlReaderSettings()
{
}))
{
while (xaml.Read())
{
switch (xaml.NodeType)
{
case XamlNodeType.NamespaceDeclaration:
renderer.WriteNamespace(xaml.Namespace);
break;
case XamlNodeType.StartObject:
renderer.WriteStartObject(xaml.Type);
break;
case XamlNodeType.GetObject:
renderer.WriteGetObject();
break;
case XamlNodeType.EndObject:
renderer.WriteEndObject();
break;
case XamlNodeType.StartMember:
renderer.WriteStartMember(xaml.Member);
break;
case XamlNodeType.EndMember:
renderer.WriteEndMember();
break;
case XamlNodeType.Value:
if (xaml.Value is string text)
{
renderer.WriteValue(text);
}
else
{
renderer.WriteValue(xaml.Value.ToString()); // todo: use xaml to text converter
}
break;
default:
throw new InvalidOperationException();
}
}
}
} // proc Write
private XamlMemberDefinition VisitMember(XamlXmlReader reader, XamlObjectDefinition owner)
{
var member = new XamlMemberDefinition(reader.Member, reader.LineNumber, reader.LinePosition, owner);
while (reader.Read())
{
WriteState(reader);
switch (reader.NodeType)
{
case XamlNodeType.EndMember:
_depth--;
return(member);
case XamlNodeType.Value:
if (IsLiteralInlineText(reader.Value, member, owner))
{
var run = ConvertLiteralInlineTextToRun(reader);
member.Objects.Add(run);
}
else
{
if (member.Value is string s)
{
member.Value += ", " + reader.Value;
}
else
{
member.Value = reader.Value;
}
}
break;
case XamlNodeType.StartObject:
_depth++;
member.Objects.Add(VisitObject(reader, owner));
break;
case XamlNodeType.EndObject:
_depth--;
break;
case XamlNodeType.NamespaceDeclaration:
// Skip
break;
default:
throw new InvalidOperationException("Unable to process {2} node at Line {0}, position {1}".InvariantCultureFormat(reader.LineNumber, reader.LinePosition, reader.NodeType));
}
}
return(member);
}
private void Analyze(XamlXmlReader reader) {
Stack<XamlType> objectTypes = new Stack<XamlType>();
Stack<MemberType> nameStack = new Stack<MemberType>();
Stack<XamlMember> eventStack = new Stack<XamlMember>();
while (reader.Read()) {
switch (reader.NodeType) {
case XamlNodeType.StartObject: objectTypes.Push(reader.Type); break;
case XamlNodeType.EndObject:
if (objectTypes.Count > 0) {
objectTypes.Pop();
}
break;
case XamlNodeType.NamespaceDeclaration:
break;
case XamlNodeType.StartMember:
var property = reader.Member;
if (property.Name == "Name" && property.Type.UnderlyingType == typeof(string)) {
nameStack.Push(MemberType.XName);
} else if (property.IsEvent) {
nameStack.Push(MemberType.Event);
eventStack.Push(property);
} else {
nameStack.Push(MemberType.Unknown);
}
break;
case XamlNodeType.EndMember:
if (nameStack.Pop() == MemberType.Event) {
eventStack.Pop();
}
break;
case XamlNodeType.GetObject:
case XamlNodeType.Value:
object value = reader.Value;
if (value is string) {
switch (nameStack.Peek()) {
case MemberType.XName:
// we are writing a x:Name, save it so we can later get the name from the scope
_knownTypes[(string)value] = new XamlTypeReference(objectTypes.Peek(), reader.LineNumber, reader.LinePosition);
break;
case MemberType.Event:
// we have an event handler, save the method name and the XamlMember for the event
_eventInfo[(string)value] = new XamlMemberReference(eventStack.Peek(), reader.LineNumber, reader.LinePosition);
break;
}
}
break;
}
}
}
public static object Deserialize(this XamlSchemaContext schemaContext, string xaml)
{
using (var sr = new StringReader(xaml))
using (var xor = new XamlXmlReader(sr, schemaContext))
using (var xxw = new XamlObjectWriter(schemaContext))
{
while (xor.Read())
{
xxw.WriteNode(xor);
}
return(xxw.Result);
}
}
public MainWindow()
{
InitializeComponent();
using (var reader = new XamlXmlReader("./Button.xaml"))
using (var writer = new XamlXmlWriter(new FileStream("./Test.xaml", FileMode.Create), reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
}
using (var reader = new XamlObjectReader(new Button()))
using (var writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
var button = (Button)writer.Result;
}
using (var reader = new XamlXmlReader(new StringReader("<Button xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\">This is a button</Button>")))
using (var writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
var button = (Button)writer.Result;
}
var button1 = (Button)XamlServices.Load("./Button.xaml");
var button2 = XamlServices.Load(new XamlObjectReader(new Button()));
var button3 = XamlServices.Load(new StringReader("<Button xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\">This is a button</Button>"));
var button4 = XamlServices.Parse("<Button xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\">This is a button</Button>");
XamlServices.Save("./Test2.xaml", new Button());
//DispatcherObject methods, hidden from intellisense via the EditorBrowsableAttribute
button1.CheckAccess();
button1.VerifyAccess();
}
public void UnknownContentWS()
{
XamlXmlReader xxr = new XamlXmlReader(new MemoryStream(ASCIIEncoding.Default.GetBytes(RobPanel)));
bool containsWS = false;
while (xxr.Read())
{
if ((xxr.NodeType == XamlNodeType.Value) && ((string)xxr.Value == " "))
{
containsWS = true;
}
}
if (!containsWS)
{
throw new Exception("Whitespace expected in unknown content");
}
}
private IEnumerable <Node> XmlToNodes(string x, XamlXmlReaderSettings xamlXmlReaderSettings)
{
XamlXmlReader r = new XamlXmlReader(XmlReader.Create(new StringReader(x)), xamlXmlReaderSettings);
while (r.Read())
{
switch (r.NodeType)
{
case XamlNodeType.EndMember:
yield return(new EM());
break;
case XamlNodeType.EndObject:
yield return(new EO());
break;
case XamlNodeType.GetObject:
yield return(new GO());
break;
case XamlNodeType.NamespaceDeclaration:
yield return(new NS(r.Namespace));
break;
case XamlNodeType.StartMember:
yield return(new SM(r.Member));
break;
case XamlNodeType.StartObject:
yield return(new SO(r.Type));
break;
case XamlNodeType.Value:
yield return(new V(r.Value));
break;
}
}
}
public static TOutput XamlStringToObject <TOutput>(this string xmlString)
{
XamlSchemaContext schemaContext = System.Windows.Markup.XamlReader.GetWpfSchemaContext();
XamlXmlReaderSettings settings = new XamlXmlReaderSettings()
{
LocalAssembly = Assembly.GetExecutingAssembly()
};
using (XamlXmlReader reader = new XamlXmlReader(new StringReader(xmlString), schemaContext, settings))
using (XamlObjectWriter writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
return((TOutput)writer.Result);
}
}
private static T Get <T>(string path)
{
using (var stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(path))
{
// создаем экземпляр валидатора
XamlXmlReader xxr = new XamlXmlReader(stream);
//where xamlStringToLoad is a string of well formed XAML
XamlObjectWriter xow = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
{
xow.WriteNode(xxr);
}
return((T)xow.Result);
}
}
public void DeserializationTest(string xaml, Type expectedType, string expectedValue)
{
var sc = GetContext();
using (var sr = new StringReader(xaml))
using (var xxr = new XamlXmlReader(sr, sc))
using (var xow = new XamlObjectWriter(sc))
{
while (xxr.Read())
{
xow.WriteNode(xxr);
}
Assert.IsType(expectedType, xow.Result);
Assert.Equal(
expectedValue,
(xow.Result as IFormattable)?.ToString(null, CultureInfo.InvariantCulture) ?? xow.Result?.ToString());
}
}
public void TestBaseUri3()
{
string xaml = @"
<c:ArrayList xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
xmlns:s='clr-namespace:System;assembly=mscorlib'
xmlns:c='clr-namespace:System.Collections;assembly=mscorlib' xml:base='http://schemas.microsoft.com/winfx/2006/xaml'>
<s:String>Hello</s:String>
</c:ArrayList>";
TextReader textReader = new StringReader(xaml);
XamlXmlReaderSettings settings = new XamlXmlReaderSettings();
XamlXmlReader xxr = new XamlXmlReader(textReader, settings);
XamlObjectWriter objWriter = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
{
objWriter.WriteNode(xxr);
}
objWriter.Clear();
objWriter.Close();
}
public static Viewbox GetViewboxFromXAML(string XAML)
{
System.IO.StringReader sr = new System.IO.StringReader(XAML);
XamlXmlReader xxr = new XamlXmlReader(sr);
XamlObjectWriter xow = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
{
xow.WriteNode(xxr);
}
sr.Close();
Viewbox vb = (Viewbox)xow.Result;
vb.HorizontalAlignment = HorizontalAlignment.Stretch;
vb.VerticalAlignment = VerticalAlignment.Stretch;
return(vb);
}
private IEnumerable <Message> DoExtractMessagesFromFile([NotNull] UFile file, [NotNull] XamlXmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType != XamlNodeType.StartObject)
{
continue;
}
var lineNumber = reader.LineNumber;
var type = reader.Type.UnderlyingType;
if (type == typeof(LocalizeExtension))
{
var readSubtree = reader.ReadSubtree();
readSubtree.Read(); // read once to position on the first node
var message = ParseLocalizeExtension(readSubtree);
message.LineNumber = lineNumber;
message.Source = file;
yield return(message);
}
}
}
/// <summary>
/// Loads XAML from the specified XamlXmlReader and returns the deserialized object. Any event handlers
/// are bound to methods defined in the provided Scope and converted using the provided DynamicOperations
/// object.
/// </summary>
public static object LoadComponent(dynamic scope, DynamicOperations operations, XamlXmlReader reader)
{
var settings = new XamlObjectWriterSettings();
settings.RootObjectInstance = scope;
var myWriter = new DynamicWriter((object)scope, operations, reader.SchemaContext, settings);
while (reader.Read())
{
myWriter.WriteNode(reader);
}
foreach (string name in myWriter.Names)
{
object value = myWriter.RootNameScope.FindName(name);
if (value != null)
{
operations.SetMember((object)scope, name, value);
}
}
return(myWriter.Result);
}
/// <summary>
/// Compiling the workflow xamls into the assembly.
/// </summary>
internal void Compile(List <string> dependentWorkflows, Dictionary <string, string> requiredAssemblies)
{
if (IsRunningOnProcessorArchitectureARM())
{
Tracer.WriteMessage("The workflow Calling workflow is not supported so throwing the exception.");
throw new NotSupportedException(Resources.WFCallingWFNotSupported);
}
// Note that the _NOT_ARMBUILD_ flag is not a global build flag and needs to be set in the corresponding sources.inc file as appropriate.
#if _NOTARMBUILD_
DirectoryInfo folder = new DirectoryInfo(this.ProjectFolderPath);
folder.Create();
List <string> workflowFiles = new List <string>();
try
{
// Dump the files
foreach (string dependentWorkflow in dependentWorkflows)
{
string newFileName = Path.Combine(this.ProjectFolderPath, Path.GetRandomFileName() + ".xaml");
File.WriteAllText(newFileName, dependentWorkflow);
workflowFiles.Add(newFileName);
}
File.WriteAllText(this.ProjectFilePath, Template_Project);
}
catch (Exception e)
{
Tracer.TraceException(e);
throw;
}
using (ProjectCollection projects = new ProjectCollection())
{
Project project = projects.LoadProject(this.ProjectFilePath);
project.SetProperty("AssemblyName", this.AssemblyName);
HashSet <string> Assemblies = new HashSet <string>();
foreach (string file in workflowFiles)
{
project.AddItem("XamlAppDef", file);
XamlXmlReader reader = new XamlXmlReader(XmlReader.Create(file, new XmlReaderSettings {
XmlResolver = null
}), new XamlSchemaContext());
using (reader)
{
while (reader.Read())
{
if (reader.NodeType == XamlNodeType.NamespaceDeclaration)
{
string _namespace = reader.Namespace.Namespace.ToLowerInvariant();
if (_namespace.IndexOf("assembly=", StringComparison.OrdinalIgnoreCase) > -1)
{
List <string> filters = new List <string>();
filters.Add("assembly=");
string[] results = _namespace.Split(filters.ToArray(), StringSplitOptions.RemoveEmptyEntries);
if (results.Length > 1 && !string.IsNullOrEmpty(results[1]))
{
string requiredAssemblyLocation;
if (requiredAssemblies != null && requiredAssemblies.Count > 0 && requiredAssemblies.TryGetValue(results[1], out requiredAssemblyLocation))
{
Assemblies.Add(requiredAssemblyLocation);
}
else
{
Assemblies.Add(results[1]);
}
}
}
}
}
}
}
foreach (string assembly in Assemblies)
{
project.AddItem("Reference", assembly);
}
project.Save(this.ProjectFilePath);
FileLogger logger = new FileLogger();
logger.Parameters = "logfile=" + this.BuildLogPath;
this.BuildReturnedCode = false;
// According to MSDN, http://msdn.microsoft.com/en-us/library/microsoft.build.evaluation.projectcollection.aspx
// multiple project collections can exist within an app domain. However, these must not build concurrently.
// Therefore, we need a static lock to prevent multiple threads from accessing this call.
lock (_syncObject)
{
this.BuildReturnedCode = project.Build(logger);
}
logger.Shutdown();
// If compilation succeeded, delete the project files.
//
if (this.BuildReturnedCode)
{
string generatedAssemblyPath = Path.Combine(this.ProjectFolderPath, @"obj\Release\" + this.ProjectName + ".dll");
if (File.Exists(generatedAssemblyPath))
{
File.Move(generatedAssemblyPath, this.AssemblyPath);
}
try
{
System.IO.Directory.Delete(this.ProjectFolderPath, true);
}
catch (Exception e)
{
Tracer.TraceException(e);
// Ignoring the exceptions from Delete of temp directory.
}
}
}
#endif
}
private bool ParseInput()
{
XamlXmlReader reader = null;
try {
try {
reader = new XamlXmlReader(InputFileName.ItemSpec, new XamlXmlReaderSettings {
ProvideLineInfo = true
});
} catch (FileNotFoundException ex) {
LogError(1001, ex.Message);
return(false);
}
bool classNameExpected = false, classModifierExpected = false;
bool lambdaBodyExpected = false, importedNamespacesExpected = false;
int nestingLevel = 0, lambdaNestingLevel = -1;
while (reader.Read())
{
switch (reader.NodeType)
{
case XamlNodeType.GetObject:
++nestingLevel;
break;
case XamlNodeType.StartObject:
++nestingLevel;
if (nestingLevel == 1)
{
classNameLineNumber = reader.LineNumber;
}
if ((reader.Type.Name == "Lambda" || reader.Type.Name == "LambdaExtension") && IsLambdaNamespace(reader.Type.PreferredXamlNamespace))
{
lambdaNestingLevel = nestingLevel;
}
break;
case XamlNodeType.EndObject:
--nestingLevel;
if (nestingLevel < lambdaNestingLevel)
{
lambdaNestingLevel = -1;
}
break;
case XamlNodeType.StartMember:
if (nestingLevel == 1)
{
if (reader.Member.PreferredXamlNamespace == XamlLanguage.Xaml2006Namespace)
{
switch (reader.Member.Name)
{
case "Class": {
classNameExpected = true;
} break;
case "ClassModifier": {
classModifierExpected = true;
} break;
}
}
else if (reader.Member.DeclaringType != null && IsLambdaNamespace(reader.Member.DeclaringType.PreferredXamlNamespace))
{
if (reader.Member.Name == "ImportedNamespaces" && reader.Member.DeclaringType.Name == "LambdaProperties")
{
importedNamespacesExpected = true;
}
}
}
else if (nestingLevel == lambdaNestingLevel)
{
if (reader.Member == XamlLanguage.UnknownContent || reader.Member == XamlLanguage.PositionalParameters || reader.Member.Name == "Lambda")
{
lambdaBodyExpected = true;
}
}
break;
case XamlNodeType.EndMember:
classNameExpected = lambdaBodyExpected = importedNamespacesExpected = false;
break;
case XamlNodeType.Value:
if (classNameExpected)
{
classNameExpected = false;
className = (string)reader.Value;
classNameLineNumber = reader.LineNumber;
}
else if (classModifierExpected)
{
classModifierExpected = false;
classModifier = (string)reader.Value;
classModifierLineNumber = reader.LineNumber;
}
else if (importedNamespacesExpected)
{
importedNamespaces.Clear();
importedNamespaces.AddRange(((string)reader.Value).Split(" \f\n\r\t".ToCharArray(), StringSplitOptions.RemoveEmptyEntries));
importedNamespacesLineNumber = reader.LineNumber;
}
else if (lambdaBodyExpected)
{
lambdas.Add(new LambdaInfo {
Code = (string)reader.Value, LineNumber = reader.LineNumber
});
}
break;
}
}
} catch (IOException ex) {
LogError(1002, ex.Message);
return(false);
} catch (XmlException ex) {
LogError(1003, ex.Message);
return(false);
} catch (XamlException ex) {
LogError(1004, ex.Message);
return(false);
} finally {
if (reader != null)
{
reader.Close();
}
}
return(true);
}
public static void LoadI18N()
{
var locale = AppSettings.Default.Interface.Locale;
_i18nDic = App.Current.Resources.MergedDictionaries[0];
var defLocale = _i18nDic.MergedDictionaries[0];
var defUiStrings = defLocale.Keys.Cast <object>().ToDictionary(defKey => (string)defKey, defKey => (string)defLocale[defKey]);
foreach (var enumerateFile in Util.EnumerateFiles(Domain.LangPath, ".xaml"))
{
try
{
var fullText = File.ReadAllText(enumerateFile.FullName);
var localeCode = Path.GetFileNameWithoutExtension(enumerateFile.Name);
var nativeName = CultureInfo.CreateSpecificCulture(localeCode).NativeName;
if (string.IsNullOrWhiteSpace(fullText)) // 读取文件，若空则新建
{
var defUiText = string.Join("\r\n",
defUiStrings.Select(k => $@" <sys:String x:Key=""{k.Key}"">{k.Value}</sys:String>"));
var xamlTemplate = GetXamlTemplate(defUiText);
File.WriteAllText(enumerateFile.FullName, xamlTemplate);
}
else
{
// 否则分析文件，和默认的做对比，如果少了相应的字段则补齐
using (var xamlReader = new XamlXmlReader(new StringReader(fullText)))
{
string keyName = null;
(int LineNumber, int LinePosition, Type Type)? currentObj = null;
(int LineNumber, int LinePosition, string member)? currentMember = null;
int firstObjLine = 0;
var kvs = new Dictionary <string, string>();
while (!xamlReader.IsEof)
{
var result = xamlReader.Read();
if (!result)
{
continue;
}
if (xamlReader.NodeType == XamlNodeType.StartObject)
{
currentObj = (xamlReader.LineNumber, xamlReader.LinePosition, xamlReader.Type.UnderlyingType);
}
else if (xamlReader.NodeType == XamlNodeType.EndObject)
{
currentObj = null;
}
else if (xamlReader.NodeType == XamlNodeType.EndMember)
{
currentMember = null;
}
//if (currentObj?.Type == typeof(ResourceDictionary))
//{
// if (xamlReader.NodeType == XamlNodeType.StartMember)
// {
// currentMember = (xamlReader.LineNumber, xamlReader.LinePosition, xamlReader.Member.Name);
// }
// else if (xamlReader.NodeType == XamlNodeType.Value && currentMember?.member == "Name")
// {
// langName = (string)xamlReader.Value;
// }
//}
//else
if (currentObj?.Type == typeof(string))
{
if (xamlReader.NodeType == XamlNodeType.StartMember)
{
currentMember = (xamlReader.LineNumber, xamlReader.LinePosition, xamlReader.Member.Name);
}
else if (xamlReader.NodeType == XamlNodeType.Value && currentMember?.member == "Key")
{
keyName = (string)xamlReader.Value;
}
else if (xamlReader.NodeType == XamlNodeType.Value && currentMember?.member == "_Initialization")
{
if (kvs.Count == 0)
{
firstObjLine = xamlReader.LineNumber;
}
kvs.Add(keyName, (string)xamlReader.Value);
}
}
}
var unspecifiedKvs = defUiStrings.Where(k => !kvs.ContainsKey(k.Key)).ToList(); // 是否缺少字段
if (unspecifiedKvs.Count > 0)
{
var kvStr = string.Join("\r\n",
unspecifiedKvs.Select(k => $@" <sys:String x:Key=""{k.Key}"">{k.Value}</sys:String>"));
using (var sr = new StringReader(fullText))
using (var sw = new StreamWriter(enumerateFile.FullName))
{
int i = 1;
string line = sr.ReadLine();
while (line != null)
{
if (i == firstObjLine)
{
sw.WriteLine(kvStr);
}
sw.WriteLine(line);
line = sr.ReadLine();
i++;
}
}
}
}
}
AvailableLangDic.Add(nativeName, localeCode);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
if (!AvailableLangDic.ContainsValue("zh-CN"))
{
var chiUiText = string.Join("\r\n",
defUiStrings.Select(k => $@" <sys:String x:Key=""{k.Key}"">{k.Value}</sys:String>"));
var nativeName = CultureInfo.CreateSpecificCulture("zh-CN").NativeName;
File.WriteAllText(Path.Combine(Domain.LangPath, "zh-CN.xaml"), GetXamlTemplate(chiUiText));
AvailableLangDic.Add(nativeName, "zh-CN");
}
SwitchToLang(string.IsNullOrWhiteSpace(locale) ? CultureInfo.CurrentCulture.Name : locale);
}
internal void Compile(List <string> dependentWorkflows, Dictionary <string, string> requiredAssemblies)
{
string str = null;
DirectoryInfo directoryInfo = new DirectoryInfo(this.ProjectFolderPath);
directoryInfo.Create();
List <string> strs = new List <string>();
try
{
foreach (string dependentWorkflow in dependentWorkflows)
{
string str1 = Path.Combine(this.ProjectFolderPath, string.Concat(Path.GetRandomFileName(), ".xaml"));
File.WriteAllText(str1, dependentWorkflow);
strs.Add(str1);
}
File.WriteAllText(this.ProjectFilePath, "<?xml version=\"1.0\" encoding=\"utf-8\"?><Project ToolsVersion=\"4.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\"><PropertyGroup><Configuration Condition=\" '$(Configuration)' == '' \">Release</Configuration><Platform Condition=\" '$(Platform)' == '' \">AnyCPU</Platform><ProductVersion>10.0</ProductVersion><SchemaVersion>2.0</SchemaVersion><OutputType>Library</OutputType><AppDesignerFolder>Properties</AppDesignerFolder><TargetFrameworkVersion>v4.0</TargetFrameworkVersion><TargetFrameworkProfile></TargetFrameworkProfile><FileAlignment>512</FileAlignment></PropertyGroup><PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' \"><DebugSymbols>true</DebugSymbols><DebugType>full</DebugType><Optimize>false</Optimize><OutputPath>bin\\Debug\\</OutputPath><DefineConstants>DEBUG;TRACE</DefineConstants><ErrorReport>prompt</ErrorReport><WarningLevel>4</WarningLevel></PropertyGroup><PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' \"><DebugType>pdbonly</DebugType><Optimize>true</Optimize><OutputPath>bin\\Release\\</OutputPath><DefineConstants>TRACE</DefineConstants><ErrorReport>prompt</ErrorReport><WarningLevel>4</WarningLevel></PropertyGroup><ItemGroup><Reference Include=\"Microsoft.CSharp\" /><Reference Include=\"System\" /><Reference Include=\"System.Activities\" /><Reference Include=\"System.Core\" /><Reference Include=\"System.Data\" /><Reference Include=\"System.ServiceModel\" /><Reference Include=\"System.ServiceModel.Activities\" /><Reference Include=\"System.Xaml\" /><Reference Include=\"System.Xml\" /><Reference Include=\"System.Xml.Linq\" /><Reference Include=\"System.Management\" /><Reference Include=\"System.Management.Automation\" /><Reference Include=\"Microsoft.PowerShell.Workflow.ServiceCore\" /></ItemGroup><Import Project=\"$(MSBuildToolsPath)\\Microsoft.CSharp.targets\" /><!-- To modify your build process, add your task inside one of the targets below and uncomment it. Other similar extension points exist, see Microsoft.Common.targets. <Target Name=\"BeforeBuild\"></Target><Target Name=\"AfterBuild\"></Target>--></Project>");
}
catch (Exception exception1)
{
Exception exception = exception1;
WorkflowRuntimeCompilation.Tracer.TraceException(exception);
throw;
}
using (ProjectCollection projectCollection = new ProjectCollection())
{
Project project = projectCollection.LoadProject(this.ProjectFilePath);
project.SetProperty("AssemblyName", this.AssemblyName);
HashSet <string> strs1 = new HashSet <string>();
foreach (string str2 in strs)
{
project.AddItem("XamlAppDef", str2);
XamlXmlReader xamlXmlReader = new XamlXmlReader(XmlReader.Create(str2), new XamlSchemaContext());
using (xamlXmlReader)
{
while (xamlXmlReader.Read())
{
if (xamlXmlReader.NodeType != XamlNodeType.NamespaceDeclaration)
{
continue;
}
string lowerInvariant = xamlXmlReader.Namespace.Namespace.ToLowerInvariant();
if (lowerInvariant.IndexOf("assembly=", StringComparison.OrdinalIgnoreCase) <= -1)
{
continue;
}
List <string> strs2 = new List <string>();
strs2.Add("assembly=");
string[] strArrays = lowerInvariant.Split(strs2.ToArray(), StringSplitOptions.RemoveEmptyEntries);
if ((int)strArrays.Length <= 1 || string.IsNullOrEmpty(strArrays[1]))
{
continue;
}
if (requiredAssemblies == null || requiredAssemblies.Count <= 0 || !requiredAssemblies.TryGetValue(strArrays[1], out str))
{
strs1.Add(strArrays[1]);
}
else
{
strs1.Add(str);
}
}
}
}
foreach (string str3 in strs1)
{
project.AddItem("Reference", str3);
}
project.Save(this.ProjectFilePath);
FileLogger fileLogger = new FileLogger();
fileLogger.Parameters = string.Concat("logfile=", this.BuildLogPath);
this.BuildReturnedCode = false;
lock (WorkflowRuntimeCompilation._syncObject)
{
this.BuildReturnedCode = project.Build(fileLogger);
}
fileLogger.Shutdown();
if (this.BuildReturnedCode)
{
string str4 = Path.Combine(this.ProjectFolderPath, string.Concat("obj\\Release\\", this.ProjectName, ".dll"));
if (File.Exists(str4))
{
File.Move(str4, this.AssemblyPath);
}
try
{
Directory.Delete(this.ProjectFolderPath, true);
}
catch (Exception exception3)
{
Exception exception2 = exception3;
WorkflowRuntimeCompilation.Tracer.TraceException(exception2);
}
}
}
}
