// This method reads ViewStateManager nodes from the xaml nodestream and outputs that in the
// viewStateInfo dictionary. The input reader is positioned at the begining of the workflow definition.
// The method returns a reader positioned at the begining of the workflow definition with the ViewStateManager
// nodes removed.
static XamlReader StripViewStateElement(XamlReader inputReader, out Dictionary <string, XamlNodeList> viewStateInfo, out Dictionary <string, SourceLocation> viewStateSourceLocationMap)
{
viewStateSourceLocationMap = null;
XamlNodeList strippedNodeList = new XamlNodeList(inputReader.SchemaContext);
XamlMember viewStateManager = new XamlMember(ViewStateManager, GetViewStateManager, SetViewStateManager, inputReader.SchemaContext);
using (XamlWriter strippedWriter = strippedNodeList.Writer)
{
IXamlLineInfo lineInfo = inputReader as IXamlLineInfo;
IXamlLineInfoConsumer lineInfoComsumer = strippedWriter as IXamlLineInfoConsumer;
bool shouldPassLineInfo = lineInfo != null && lineInfo.HasLineInfo && lineInfoComsumer != null && lineInfoComsumer.ShouldProvideLineInfo;
viewStateInfo = null;
while (inputReader.Read())
{
if (inputReader.NodeType == XamlNodeType.StartMember && inputReader.Member.Equals(viewStateManager))
{
ReadViewStateInfo(inputReader.ReadSubtree(), out viewStateInfo, out viewStateSourceLocationMap);
}
if (shouldPassLineInfo)
{
lineInfoComsumer.SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
}
strippedWriter.WriteNode(inputReader);
}
}
return(strippedNodeList.GetReader());
}
ClassData ReadClassData(XamlNodeList xamlNodes, string xamlFileName)
{
ClassImporter importer = new ClassImporter(xamlFileName, this.AssemblyName, this.Language.Equals("VB") ? this.RootNamespace : null);
ClassData classData = importer.ReadFromXaml(xamlNodes);
return(classData);
}
public void ReadWriteListShouldRoundtrip()
{
var sc = new XamlSchemaContext();
var list = new XamlNodeList(sc);
var reader = new XamlObjectReader(new TestClass4 { Foo = "foo", Bar = "bar" }, sc);
XamlServices.Transform(reader, list.Writer);
var writer = new XamlObjectWriter(sc);
var listReader = list.GetReader();
XamlServices.Transform(listReader, writer);
Assert.IsNotNull(writer.Result, "#1");
Assert.IsInstanceOf<TestClass4>(writer.Result, "#2");
Assert.AreEqual("foo", ((TestClass4)writer.Result).Foo, "#3");
Assert.AreEqual("bar", ((TestClass4)writer.Result).Bar, "#4");
// try reading a 2nd time, we should not get the same reader
writer = new XamlObjectWriter(sc);
var listReader2 = list.GetReader();
Assert.AreNotSame(listReader, listReader2, "#5");
XamlServices.Transform(listReader2, writer);
Assert.IsNotNull(writer.Result, "#6");
Assert.IsInstanceOf<TestClass4>(writer.Result, "#7");
Assert.AreEqual("foo", ((TestClass4)writer.Result).Foo, "#8");
Assert.AreEqual("bar", ((TestClass4)writer.Result).Bar, "#9");
}
public FooContainerFactory(IXamlObjectWriterFactory objectWriterFactory, XamlReader xamlReader)
{
this.nodeList = new XamlNodeList(xamlReader.SchemaContext);
XamlServices.Transform(xamlReader, nodeList.Writer);
this.objectWriterFactory = objectWriterFactory;
}
public void ReadWriteListShouldRoundtrip()
{
var sc = new XamlSchemaContext();
var list = new XamlNodeList(sc);
var reader = new XamlObjectReader(new TestClass4 {
Foo = "foo", Bar = "bar"
}, sc);
XamlServices.Transform(reader, list.Writer);
var writer = new XamlObjectWriter(sc);
var listReader = list.GetReader();
XamlServices.Transform(listReader, writer);
Assert.IsNotNull(writer.Result, "#1");
Assert.IsInstanceOf <TestClass4>(writer.Result, "#2");
Assert.AreEqual("foo", ((TestClass4)writer.Result).Foo, "#3");
Assert.AreEqual("bar", ((TestClass4)writer.Result).Bar, "#4");
// try reading a 2nd time, we should not get the same reader
writer = new XamlObjectWriter(sc);
var listReader2 = list.GetReader();
Assert.AreNotSame(listReader, listReader2, "#5");
XamlServices.Transform(listReader2, writer);
Assert.IsNotNull(writer.Result, "#6");
Assert.IsInstanceOf <TestClass4>(writer.Result, "#7");
Assert.AreEqual("foo", ((TestClass4)writer.Result).Foo, "#8");
Assert.AreEqual("bar", ((TestClass4)writer.Result).Bar, "#9");
}
public void WriterShouldThrowExceptionIfNotClosed()
{
var sc = new XamlSchemaContext();
var list = new XamlNodeList(sc);
list.Writer.WriteStartObject(sc.GetXamlType(typeof(TestClass4)));
list.Writer.WriteEndObject();
Assert.Throws<XamlException> (() => list.GetReader());
}
bool ValidateXaml(XamlNodeList xamlNodeList, string xamlFileName)
{
using (XamlReader xamlReader = xamlNodeList.GetReader())
{
IList <LogData> validationErrors = null;
ClassValidator validator = new ClassValidator(xamlFileName, null, null);
return(validator.ValidateXaml(xamlReader, true, this.AssemblyName, out validationErrors));
}
}
public void WriterShouldThrowExceptionIfNotClosed()
{
var sc = new XamlSchemaContext();
var list = new XamlNodeList(sc);
list.Writer.WriteStartObject(sc.GetXamlType(typeof(TestClass4)));
list.Writer.WriteEndObject();
Assert.Throws <XamlException> (() => list.GetReader());
}
private static ICustomTypeDescriptor LoadAndValidateActivity(XamlNodeList xamlNodes)
{
object result = LoadActivity(xamlNodes);
if (result == null || !result.GetType().IsDynamicActivity())
{
throw new ArgumentException("The root type of the XAML must be Activity, and the root element must contain an x:Class directive", "xamlNodes");
}
return((ICustomTypeDescriptor)result);
}
internal static void WriteNodeList(XamlWriter writer, XamlNodeList nodeList)
{
// We need to pass the ErrorNodes contents through as a NodeList, because XOW doesn't
// currently support unknown types, even inside a DeferLoad block.
// But if a NodeList is written to XOW as a Value, XOW will unpack, forcing us to re-buffer
// the nodes in our deferring loader. So we wrap the NodeList value inside a dummy StartObject.
writer.WriteStartObject(XamlLanguage.Object);
writer.WriteStartMember(XamlLanguage.Initialization);
writer.WriteValue(nodeList);
writer.WriteEndMember();
writer.WriteEndObject();
}
public TemplateContent(IEnumerable <NamespaceDeclaration> namespaces, XamlReader reader)
{
List = new XamlNodeList(reader.SchemaContext);
//we need to rpeserve all namespace and prefixes to writer
//otherwise they are lost. a bug in Portable.xaml or by design ??
foreach (var ns in namespaces)
{
List.Writer.WriteNamespace(ns);
}
XamlServices.Transform(reader, List.Writer);
}
public DynamicActivityXamlType(XamlNodeList xamlNodes, IEnumerable <string> xamlNamespaces)
: base(LoadAndValidateActivity(xamlNodes.CheckNotNull("xamlNodes")), xamlNodes.Writer.SchemaContext)
{
XamlNodes = xamlNodes;
if (xamlNamespaces != null)
{
List <string> namespaces = xamlNamespaces.ToList();
if (namespaces.Count > 0)
{
namespaces.Add(ClrNamespace);
_namespaces = namespaces.AsReadOnly();
}
}
}
private DynamicActivityXamlType CreateXamlType(string path)
{
XamlNodeList xamlNodes = new XamlNodeList(this);
using (XamlXmlReader xamlReader = new XamlXmlReader(path, this))
{
XamlServices.Transform(xamlReader, xamlNodes.Writer);
}
// Namespaces are only evaluated at construction, so if an additional namespace is
// registered later, we don't update the XamlType.
IEnumerable <string> namespaces = GetNamespacesFor(path).OrderBy(ns => ns, StringComparer.Ordinal);
DynamicActivityXamlType result = new DynamicActivityXamlType(xamlNodes, namespaces);
return(result);
}
public override object StandardXamlLoader(string xamlString)
{
XamlSchemaContext xsc = System.Windows.Markup.XamlReader.GetWpfSchemaContext();
XamlNodeList xamlNodeList = new XamlNodeList(xsc);
XamlServices.Transform(new XamlXmlReader(XmlReader.Create(new StringReader(xamlString)), xsc), xamlNodeList.Writer);
NodeListValidator.Validate(xamlNodeList);
System.Xaml.XamlReader reader = xamlNodeList.GetReader();
object root = System.Windows.Markup.XamlReader.Load(reader);
if (root == null)
{
throw new NullReferenceException("Load returned null Root");
}
return(root);
}
public override object Load(XamlReader xamlReader, IServiceProvider serviceProvider)
{
IXamlSchemaContextProvider schema = (IXamlSchemaContextProvider)serviceProvider.GetService(typeof(IXamlSchemaContextProvider));
XamlNodeList nodeList = new XamlNodeList(schema.SchemaContext);
Dictionary <string, Type> typesByName = new Dictionary <string, Type>();
bool nextValueIsName = false;
Type currentType = null;
using (XamlWriter writer = nodeList.Writer)
{
while (xamlReader.Read())
{
switch (xamlReader.NodeType)
{
case XamlNodeType.StartObject:
currentType = xamlReader.Type.UnderlyingType;
break;
case XamlNodeType.StartMember:
// HACK: This matches any Name property. Should probably just match
// FrameworkElement and x:Name but this'll do for now...
if (xamlReader.Member.Name == "Name")
{
nextValueIsName = true;
}
break;
case XamlNodeType.Value:
if (nextValueIsName)
{
typesByName.Add((string)xamlReader.Value, currentType);
nextValueIsName = false;
}
break;
}
writer.WriteNode(xamlReader);
}
}
return(new TemplateContent(nodeList, typesByName));
}
// Given the viewStateInfo dictionary, this method returns a xaml node list matching a ViewStateManager
// object.
static XamlNodeList CreateViewStateManagerNodeList(Dictionary <string, XamlNodeList> viewStateInfo, XamlSchemaContext schemaContext)
{
XamlNodeList viewStateManagerNodeList = new XamlNodeList(schemaContext);
XamlMember viewStateDataMember = new XamlMember(typeof(ViewStateManager).GetProperty("ViewStateData"), schemaContext);
XamlType viewStateManagerType = new XamlType(typeof(ViewStateManager), schemaContext);
XamlType viewStateDataType = new XamlType(typeof(ViewStateData), schemaContext);
XamlMember idMember = new XamlMember(typeof(ViewStateData).GetProperty("Id"), schemaContext);
using (XamlWriter viewStateManagerNodeWriter = viewStateManagerNodeList.Writer)
{
viewStateManagerNodeWriter.WriteStartObject(viewStateManagerType);
viewStateManagerNodeWriter.WriteStartMember(viewStateDataMember);
viewStateManagerNodeWriter.WriteGetObject();
viewStateManagerNodeWriter.WriteStartMember(XamlLanguage.Items);
foreach (KeyValuePair <string, XamlNodeList> entry in viewStateInfo)
{
viewStateManagerNodeWriter.WriteStartObject(viewStateDataType);
viewStateManagerNodeWriter.WriteStartMember(idMember);
viewStateManagerNodeWriter.WriteValue(entry.Key);
viewStateManagerNodeWriter.WriteEndMember(); // idMember
XamlReader viewStateValueReader = entry.Value.GetReader();
while (viewStateValueReader.Read())
{
viewStateManagerNodeWriter.WriteNode(viewStateValueReader);
}
viewStateManagerNodeWriter.WriteEndObject(); // viewStateDataType
}
viewStateManagerNodeWriter.WriteEndMember(); // XamlLanguage.Items
viewStateManagerNodeWriter.WriteEndObject(); // GetObject
viewStateManagerNodeWriter.WriteEndMember(); // viewStateDataMember
viewStateManagerNodeWriter.WriteEndObject(); // viewStateManagerType
viewStateManagerNodeWriter.Close();
}
return(viewStateManagerNodeList);
}
public virtual object StandardXamlLoader(string xamlString)
{
var xamlXmlReader = new XamlXmlReader(XmlReader.Create(new StringReader(xamlString)));
XamlNodeList xamlNodeList = new XamlNodeList(xamlXmlReader.SchemaContext);
XamlServices.Transform(xamlXmlReader, xamlNodeList.Writer);
NodeListValidator.Validate(xamlNodeList);
XamlReader reader = xamlNodeList.GetReader();
XamlObjectWriter objWriter = new XamlObjectWriter(reader.SchemaContext);
XamlServices.Transform(reader, objWriter);
object root = objWriter.Result;
if (root == null)
{
throw new NullReferenceException("Load returned null Root");
}
return(root);
}
public void WriteDeferred(XamlDeferringLoader loader, XamlNodeList nodeList, bool setValue)
{
nodeList.Writer.Close();
var obj = loader.Load(nodeList.GetReader(), service_provider);
var cms = CurrentMemberState;
if (cms != null)
{
cms.Value = obj;
}
else
{
var state = object_states.Peek();
state.Value = obj;
state.IsInstantiated = true;
}
if (setValue)
{
manager.Value();
}
}
XamlNodeList ReadXamlNodes(string xamlFileName)
{
XamlNodeList nodeList = new XamlNodeList(this.SchemaContext);
try
{
XamlXmlReaderSettings settings = new XamlXmlReaderSettings
{
AllowProtectedMembersOnRoot = true,
ProvideLineInfo = true
};
using (StreamReader streamReader = new StreamReader(xamlFileName))
{
XamlReader reader = new XamlXmlReader(XmlReader.Create(streamReader, new XmlReaderSettings {
XmlResolver = null
}), this.SchemaContext, settings);
XamlServices.Transform(reader, nodeList.Writer);
}
}
catch (XmlException e)
{
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, xamlFileName, e.LineNumber, e.LinePosition);
return(null);
}
catch (XamlException e)
{
XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, xamlFileName, e.LineNumber, e.LinePosition);
return(null);
}
if (nodeList.Count > 0)
{
return(nodeList);
}
else
{
return(null);
}
}
void RemoveXamlSpaceAttribute(ClassData classData)
{
using (XamlReader reader = classData.EmbeddedResourceXaml.GetReader())
{
XamlNodeList newList = new XamlNodeList(reader.SchemaContext);
using (XamlWriter writer = newList.Writer)
{
bool nodesAvailable = reader.Read();
while (nodesAvailable)
{
if (reader.NodeType == XamlNodeType.StartMember && reader.Member == XamlLanguage.Space)
{
reader.Skip();
}
else
{
writer.WriteNode(reader);
nodesAvailable = reader.Read();
}
}
}
classData.EmbeddedResourceXaml = newList;
}
}
// This method removes IdRef nodes from the nodestream. This method would be called
// when a 4.5 workflow definition is retargeted to 4.0.
public static XamlReader RemoveIdRefs(XamlObjectReader inputReader)
{
XamlMember idRefMember = new XamlMember(IdRef, GetIdRef, SetIdRef, inputReader.SchemaContext);
XamlNodeList outputNodeList = new XamlNodeList(inputReader.SchemaContext);
using (XamlWriter outputWriter = outputNodeList.Writer)
{
while (inputReader.Read())
{
if (inputReader.NodeType == XamlNodeType.StartMember && inputReader.Member.Equals(idRefMember))
{
// Exhaust the idRefMember sub-tree.
XamlReader idRefReader = inputReader.ReadSubtree();
while (idRefReader.Read())
{
;
}
}
outputWriter.WriteNode(inputReader);
}
}
return(outputNodeList.GetReader());
}
public override object StandardXamlLoader(string xamlString)
{
eventHandled = false;
var xamlXmlReader = new XamlXmlReader(XmlReader.Create(new StringReader(xamlString)));
XamlNodeList xamlNodeList = new XamlNodeList(xamlXmlReader.SchemaContext);
XamlServices.Transform(xamlXmlReader, xamlNodeList.Writer);
XamlReader reader = xamlNodeList.GetReader();
XamlObjectWriterSettings settings = new XamlObjectWriterSettings()
{
RootObjectInstance = null, AfterBeginInitHandler = ObjectCreated
};
XamlObjectWriter objWriter = new XamlObjectWriter(reader.SchemaContext, settings);
XamlServices.Transform(reader, objWriter);
object root = objWriter.Result;
if (root == null)
{
throw new NullReferenceException("Load returned null Root");
}
return(root);
}
bool ProcessDirective(XamlReader reader, ClassData classData,
NamedObject currentObject, bool isRootElement, XamlNodeList strippedXamlNodes, out bool readNextNode)
{
Fx.Assert(reader.NodeType == XamlNodeType.StartMember, "Current node should be a Start Member Node");
XamlMember member = reader.Member;
bool directiveRecognized = false;
readNextNode = false;
switch (member.Name)
{
case "Name":
// Unlike all the other directives that we process, x:Name should be written
// to the stripped output.
strippedXamlNodes.Writer.WriteStartMember(member);
string objectName = ReadAtom(reader, XamlLanguage.Name.Name);
if (!objectName.StartsWith(XamlBuildTaskServices.SerializerReferenceNamePrefix,
StringComparison.Ordinal))
{
currentObject.Name = objectName;
classData.NamedObjects.Add(currentObject);
}
strippedXamlNodes.Writer.WriteValue(objectName);
strippedXamlNodes.Writer.WriteEndMember();
directiveRecognized = true;
break;
case "Class":
if (isRootElement)
{
string fullClassName = ReadAtom(reader, XamlLanguage.Class.Name);
SetClassName(fullClassName, classData);
directiveRecognized = true;
}
break;
case "ClassModifier":
if (isRootElement)
{
string classModifier = ReadAtom(reader, XamlLanguage.ClassModifier.Name);
classData.IsPublic = XamlBuildTaskServices.IsPublic(classModifier);
directiveRecognized = true;
}
break;
case "FieldModifier":
string fieldModifier = ReadAtom(reader, XamlLanguage.FieldModifier.Name);
currentObject.Visibility = XamlBuildTaskServices.GetMemberVisibility(fieldModifier);
directiveRecognized = true;
break;
case "Code":
string codeSnippet = ReadAtom(reader, XamlLanguage.Code.Name);
classData.CodeSnippets.Add(codeSnippet);
directiveRecognized = true;
break;
case "Members":
foreach (PropertyData property in ReadProperties(reader.ReadSubtree()))
{
classData.Properties.Add(property);
}
if (!classData.RequiresCompilationPass2)
{
foreach (PropertyData property in classData.Properties)
{
if (property.Type.IsUnknown)
{
classData.RequiresCompilationPass2 = true;
break;
}
}
}
directiveRecognized = true;
readNextNode = true;
break;
case "ClassAttributes":
foreach (AttributeData attribute in ReadAttributesCollection(reader.ReadSubtree()))
{
classData.Attributes.Add(attribute);
}
directiveRecognized = true;
readNextNode = true;
break;
}
if (directiveRecognized == true && readNextNode == false)
{
reader.Read();
Fx.Assert(reader.NodeType == XamlNodeType.EndMember, "Current node should be a XamlEndmember");
}
return(directiveRecognized);
}
XamlNodeList RewriteRootNode(XamlNodeList strippedXamlNodes, string name, string @namespace)
{
// Rewrite the root node to have the name of class declared via x:Class (rather than the base class)
// Also, for any properties on the root object that are declared in this class, need to rewrite the
// namespace to include the root namespace, if there is one.
string oldNamespace = null;
if (!string.IsNullOrEmpty(this.rootNamespace))
{
oldNamespace = @namespace;
if (!string.IsNullOrEmpty(@namespace))
{
@namespace = this.rootNamespace + "." + @namespace;
}
else
{
@namespace = this.rootNamespace;
}
}
string namespaceName = string.Format(CultureInfo.InvariantCulture, "{0}{1};{2}{3}", XamlBuildTaskServices.ClrNamespaceUriNamespacePart, @namespace, XamlBuildTaskServices.ClrNamespaceUriAssemblyPart, this.localAssemblyName);
XamlReader reader = strippedXamlNodes.GetReader();
XamlSchemaContext xsc = reader.SchemaContext;
XamlNodeList newStrippedXamlNodes = new XamlNodeList(xsc);
XamlWriter writer = newStrippedXamlNodes.Writer;
int depth = 0;
XamlType rootXamlType = null;
while (reader.Read())
{
switch (reader.NodeType)
{
case XamlNodeType.StartObject:
case XamlNodeType.GetObject:
depth++;
break;
case XamlNodeType.EndObject:
depth--;
break;
}
if (reader.NodeType == XamlNodeType.StartObject && depth == 1)
{
rootXamlType = new XamlType(namespaceName, name, null, xsc);
writer.WriteStartObject(rootXamlType);
}
else if (reader.NodeType == XamlNodeType.StartMember && depth == 1 && reader.Member.IsUnknown &&
reader.Member.DeclaringType != null && reader.Member.DeclaringType.Name == rootXamlType.Name)
{
string clrNs;
XamlMember member = reader.Member;
if (XamlBuildTaskServices.TryExtractClrNs(member.PreferredXamlNamespace, out clrNs) &&
clrNs == oldNamespace)
{
// This is a member defined on the document root type, but missing the project root namespace. Fix it.
XamlMember newMember = new XamlMember(member.Name, rootXamlType, member.IsAttachable);
Fx.Assert(rootXamlType != null, "First StartObject should already have been processed");
writer.WriteStartMember(newMember);
}
else
{
writer.WriteNode(reader);
}
}
else
{
writer.WriteNode(reader);
}
}
writer.Close();
return(newStrippedXamlNodes);
}
// More validation will need to be added.
public static void Validate(XamlNodeList nodeList)
{
ValidateStartEndCounts(nodeList.GetReader());
ValidateNamespaceOnlyBeforeStartObject(nodeList.GetReader());
}
public KeyRecord(bool shared, bool sharedSet, int valuePosition, XamlSchemaContext context) :
this(shared, sharedSet, valuePosition)
{
_data = new XamlNodeList(context, 8);
}
public StaticResource(XamlType type, XamlSchemaContext schemaContext)
{
ResourceNodeList = new XamlNodeList(schemaContext, 8);
ResourceNodeList.Writer.WriteStartObject(type);
}
public TestTemplate(XamlReader xamlReader, IXamlObjectWriterFactory factory)
{
XamlObjectWriterFactory = factory;
_xamlNodeList = new XamlNodeList(xamlReader.SchemaContext);
XamlServices.Transform(xamlReader, _xamlNodeList.Writer);
}
bool ProcessMarkupItem(ITaskItem markupItem, CodeDomProvider codeDomProvider)
{
string markupItemFileName = markupItem.ItemSpec;
XamlBuildTaskServices.PopulateModifiers(codeDomProvider);
XamlNodeList xamlNodes = ReadXamlNodes(markupItemFileName);
if (xamlNodes == null)
{
return(false);
}
ClassData classData = ReadClassData(xamlNodes, markupItemFileName);
string outputFileName = GetFileName(markupItemFileName);
string codeFileName = Path.ChangeExtension(outputFileName, GetGeneratedSourceExtension(codeDomProvider));
string markupFileName = Path.ChangeExtension(outputFileName, GeneratedSourceExtension + XamlBuildTaskServices.XamlExtension);
classData.EmbeddedResourceFileName = Path.GetFileName(markupFileName);
classData.HelperClassFullName = this.HelperClassFullName;
// Check if code file with partial class exists
classData.SourceFileExists = UserProvidedFileExists(markupItemFileName, codeDomProvider);
// Store the full type name as metadata on the markup item
string rootNamespacePrefix = null;
string namespacePrefix = null;
string typeFullName = null;
if (this.Language.Equals("VB") && !String.IsNullOrWhiteSpace(classData.RootNamespace))
{
rootNamespacePrefix = classData.RootNamespace + ".";
}
if (!String.IsNullOrWhiteSpace(classData.Namespace))
{
namespacePrefix = classData.Namespace + ".";
}
if (rootNamespacePrefix != null)
{
if (namespacePrefix != null)
{
typeFullName = rootNamespacePrefix + namespacePrefix + classData.Name;
}
else
{
typeFullName = rootNamespacePrefix + classData.Name;
}
}
else
{
if (namespacePrefix != null)
{
typeFullName = namespacePrefix + classData.Name;
}
else
{
typeFullName = classData.Name;
}
}
markupItem.SetMetadata("typeName", typeFullName);
// Execute extensions here to give them a chance to mutate the ClassData before we generate code.
if (this.SupportExtensions)
{
if (!ExecuteExtensions(classData, markupItem))
{
return(false);
}
}
// Generate code file
CodeCompileUnit codeUnit = new ClassGenerator(this.BuildLogger, codeDomProvider, this.Language).Generate(classData);
WriteCode(codeDomProvider, codeUnit, codeFileName);
this.GeneratedCodeFiles.Add(codeFileName);
// Generate resource file
if (!string.IsNullOrEmpty(this.AssemblyName))
{
// Generate xaml "implementation" file
XmlWriterSettings xmlSettings = new XmlWriterSettings {
Indent = true, IndentChars = " ", CloseOutput = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(File.Open(markupFileName, FileMode.Create), xmlSettings))
{
XamlXmlWriterSettings xamlSettings = new XamlXmlWriterSettings()
{
CloseOutput = true
};
// Process EmbeddedResourceXaml to remove xml:space="preserve"
// due to a bug in XamlXmlWriter. XamlXmlWriter throws
// if there are duplicate xml:space attributes.
// It is ok to remove the xml:space attribute
// as the XamlXmlWriter would add it in the next step
// if needed.
RemoveXamlSpaceAttribute(classData);
using (XamlReader reader = classData.EmbeddedResourceXaml.GetReader())
{
using (XamlXmlWriter xamlWriter = new XamlXmlWriter(xmlWriter, reader.SchemaContext, xamlSettings))
{
XamlServices.Transform(reader, xamlWriter);
}
}
}
this.GeneratedResources.Add(markupFileName);
}
if (classData.RequiresCompilationPass2)
{
this.RequiresCompilationPass2 = true;
}
else
{
if (!this.SupportExtensions)
{
if (!ValidateXaml(xamlNodes, markupItemFileName))
{
this.RequiresCompilationPass2 = true;
}
}
else
{
// skip validation if we are doing in-proc compile
// OR if we have pass 2 extensions hooked up
// as we anyway need to run pass 2 in that case
if (!this.IsInProcessXamlMarkupCompile && !this.MarkupCompilePass2ExtensionsPresent)
{
if (!ValidateXaml(xamlNodes, markupItemFileName))
{
this.RequiresCompilationPass2 = true;
}
}
}
}
return(true);
}
// Throws InvalidOperationException at DesignTime: Input XAML contains invalid constructs for generating a class. For example, unexpected content or unknown class or field modifiers.
public ClassData ReadFromXaml(XamlNodeList nodes)
{
if (nodes == null)
{
throw FxTrace.Exception.ArgumentNull("nodeList");
}
Stack <NamedObject> currentTypes = new Stack <NamedObject>();
XamlReader reader = nodes.GetReader();
XamlSchemaContext xsc = reader.SchemaContext;
XamlNodeList strippedXamlNodes = new XamlNodeList(xsc);
XamlWriter strippedXamlNodesWriter = strippedXamlNodes.Writer;
ClassData result = new ClassData()
{
FileName = this.xamlFileName,
IsPublic = this.DefaultClassIsPublic,
RootNamespace = this.rootNamespace
};
// We loop through the provided XAML; for each node, we do two things:
// 1. If it's a directive that's relevant to x:Class, we extract the data.
// 2. Unless it's a directive that's exclusively relevant to x:Class, we write it to strippedXamlNodes.
// The result is two outputs: class data, and stripped XAML that can be used to initialize the
// an instance of the class.
bool readNextNode = false;
while (readNextNode || reader.Read())
{
bool stripNodeFromXaml = false;
readNextNode = false;
namespaceTable.ManageNamespace(reader);
switch (reader.NodeType)
{
case XamlNodeType.StartObject:
if (result.BaseType == null)
{
result.BaseType = reader.Type;
}
currentTypes.Push(new NamedObject()
{
Type = reader.Type,
Visibility = DefaultFieldVisibility,
});
break;
case XamlNodeType.EndObject:
currentTypes.Pop();
break;
case XamlNodeType.StartMember:
XamlMember member = reader.Member;
if (member.IsDirective)
{
bool isRootElement = (currentTypes.Count == 1);
stripNodeFromXaml = ProcessDirective(reader, result, currentTypes.Peek(), isRootElement, strippedXamlNodes, out readNextNode);
}
else
{
NamedObject currentType = currentTypes.Peek();
XamlType currentXamlType = currentType.Type;
if (currentXamlType.IsUnknown)
{
result.RequiresCompilationPass2 = true;
}
}
break;
case XamlNodeType.EndMember:
break;
case XamlNodeType.Value:
break;
case XamlNodeType.NamespaceDeclaration:
break;
case XamlNodeType.None:
break;
case XamlNodeType.GetObject:
//Push a dummy NamedObject so that it gets popped when you see the corresponding EndObject
currentTypes.Push(new NamedObject());
break;
default:
Debug.Fail("Unrecognized XamlNodeType value" + reader.NodeType.ToString());
break;
}
if (!stripNodeFromXaml)
{
WritestrippedXamlNode(reader, strippedXamlNodesWriter);
}
}
// ClassData.Name should be initialized to a non-null non-empty value if
// the file contains x:Class. Throw an error if neither is found.
if (result.Name == null)
{
string xClassDirectiveName = "{" + XamlLanguage.Class.PreferredXamlNamespace + "}" + XamlLanguage.Class.Name;
throw FxTrace.Exception.AsError(LogInvalidOperationException(null, SR.TaskCannotProcessFileWithoutType(xClassDirectiveName)));
}
strippedXamlNodes.Writer.Close();
strippedXamlNodes = RewriteRootNode(strippedXamlNodes, result.Name, result.Namespace);
result.EmbeddedResourceXaml = strippedXamlNodes;
return(result);
}
public XamlReaderMarkupFactory(System.Xaml.XamlReader reader, IXamlObjectWriterFactory xamlObjectWriterFactory)
{
_xamlObjectWriterFactory = xamlObjectWriterFactory;
_xamlNodeList = new XamlNodeList(reader.SchemaContext);
XamlServices.Transform(reader, _xamlNodeList.Writer);
}
// This method reads a ViewStateData node from the xaml nodestream. It outputs the Id property into viewStateId
// and the attached viewstate related properties in viewStateNodes. The input reader is positioned on a
// ViewStateData node within ViewStateManager.
static void ReadViewState(XamlType viewStateType, XamlReader xamlReader, out string viewStateId, out XamlNodeList viewStateNodes, out SourceLocation sourceLocation)
{
int globalMemberLevel = 0;
bool skippingUnexpectedAttachedProperty = false;
int skippingUnexpectedAttachedPropertyLevel = 0;
viewStateId = null;
viewStateNodes = new XamlNodeList(viewStateType.SchemaContext);
sourceLocation = null;
Stack <Frame> objectNodes = new Stack <Frame>();
XamlMember idMember = new XamlMember(typeof(ViewStateData).GetProperty("Id"), xamlReader.SchemaContext);
int[] viewStateDataSourceLocation = new int[4];
int sourceLocationIndex = -1;
IXamlLineInfo lineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer lineInfoComsumer = viewStateNodes.Writer as IXamlLineInfoConsumer;
bool shouldPassLineInfo = lineInfo != null && lineInfo.HasLineInfo && lineInfoComsumer != null && lineInfoComsumer.ShouldProvideLineInfo;
while (xamlReader.Read())
{
bool skipWritingToNodeList = false;
switch (xamlReader.NodeType)
{
case XamlNodeType.StartObject:
if (xamlReader.Type.Equals(viewStateType))
{
skipWritingToNodeList = true;
}
objectNodes.Push(new Frame {
Type = xamlReader.Type
});
break;
case XamlNodeType.GetObject:
objectNodes.Push(new Frame {
Type = null
});
break;
case XamlNodeType.StartMember:
globalMemberLevel++;
if (xamlReader.Member.Equals(idMember))
{
XamlReader idNode = xamlReader.ReadSubtree();
while (idNode.Read())
{
if (idNode.NodeType == XamlNodeType.Value)
{
viewStateId = idNode.Value as string;
}
}
}
// The xamlReader.ReadSubtree and subsequent while loop to get the Id member
// has moved the xamlReader forward to the next member. We need to check to see
// if it is an Attached Property that we care about. If it isn't then we need to
// skip it and not put it in the resulting XamlNodeList.
if (globalMemberLevel == 1 && !IsAttachablePropertyForConvert(xamlReader))
{
skippingUnexpectedAttachedProperty = true;
}
if (skippingUnexpectedAttachedProperty)
{
skippingUnexpectedAttachedPropertyLevel++;
}
sourceLocationIndex = GetViewStateDataSourceLocationIndexFromCurrentReader(xamlReader);
break;
case XamlNodeType.EndMember:
globalMemberLevel--;
if (skippingUnexpectedAttachedProperty)
{
skippingUnexpectedAttachedPropertyLevel--;
}
break;
case XamlNodeType.Value:
if (xamlReader.Value is int &&
sourceLocationIndex >= 0 &&
sourceLocationIndex < viewStateDataSourceLocation.Length)
{
viewStateDataSourceLocation[sourceLocationIndex] = (int)xamlReader.Value;
}
break;
case XamlNodeType.EndObject:
Frame objectNode = objectNodes.Pop();
if (objectNode.Type != null && objectNode.Type.Equals(viewStateType))
{
skipWritingToNodeList = true;
// The ViewStateData's source location should be valid, because
// before each EndObject, its SourceLocation is injected.
// If not, an exception will be thrown from constructor
// of SourceLocation.
sourceLocation = new SourceLocation(null,
viewStateDataSourceLocation[0],
viewStateDataSourceLocation[1],
viewStateDataSourceLocation[2],
viewStateDataSourceLocation[3]
);
}
Array.Clear(viewStateDataSourceLocation, 0, viewStateDataSourceLocation.Length);
break;
}
;
if (!skipWritingToNodeList && !skippingUnexpectedAttachedProperty)
{
if (shouldPassLineInfo)
{
lineInfoComsumer.SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
}
viewStateNodes.Writer.WriteNode(xamlReader);
}
if (skippingUnexpectedAttachedPropertyLevel == 0)
{
skippingUnexpectedAttachedProperty = false;
}
}
viewStateNodes.Writer.Close();
}
