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 }