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))
{
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 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);
}
}
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;
}
public void Parse(string input, string[] args = null)
{
var xxr = new XamlXmlReader(new StringReader(input), new XamlSchemaContext());
var graphReader = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
graphReader.WriteNode(xxr);
var page = (Page)graphReader.Result;
// Map our generators
var g = new Generator();
g.Map<Page, PageGeneratorBlock>();
g.Map<Button, ButtonGeneratorBlock>();
g.Map<StackPanel, StackPanelGeneratorBlock>();
var doc = new HtmlDocument();
var html = doc.CreateElement("html");
g.Generate(html, page);
// HTML5 Doc type
doc.DocumentNode.AppendChild(doc.CreateComment("<!DOCTYPE html>"));
doc.DocumentNode.AppendChild(html);
doc.Save("test.htm");
var cssContents = g.GenerateStyles(page);
File.WriteAllText("XamlCore.css", cssContents);
}
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;
}
}
}
private object Load(XamlXmlReader reader)
{
XamlObjectWriter writer = new ObjectWriter();
while (reader.Read())
{
writer.WriteNode(reader);
}
writer.Close();
reader.Close();
if (writer.Result is DependencyObject && !(writer is INameScope))
((DependencyObject)writer.Result).SetValue(NameScope.NameScopeProperty, writer.RootNameScope);
return writer.Result;
}
public object LoadContent()
{
_Cache.Position = 0;
XamlReader reader = new XamlXmlReader(_Cache, _SchemaContext);
XamlObjectWriter writer = new Wodsoft.Web.Xaml.ObjectWriter(reader.SchemaContext);
while (reader.Read())
{
writer.WriteNode(reader);
}
writer.Close();
reader.Close();
return writer.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();
}
/// <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;
}
public static void Load(Stream stream, object component)
{
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 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;
}
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));
}
}
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);
}
}
}
}
/// <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 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
}
