private XAMLFileDetails ParseXAMLFile(Assembly assembly, string resourceName, Stream stream)
{
XAMLFileDetails fileDetails = null;
XDocument document = new XDocument();
// Read the contents of the BAML file and decode it into a XAML document
var reader = new Baml2006Reader(stream, new XamlReaderSettings()
{
ValuesMustBeString = true, LocalAssembly = assembly
});
var writer = new XamlXmlWriter(document.CreateWriter(), reader.SchemaContext, new XamlXmlWriterSettings()
{
AssumeValidInput = true
});
while (reader.Read())
{
writer.WriteNode(reader);
}
writer.Close();
// Now check if it's a resource dictionary (which we ignore). If a normal view, parse it.
XNamespace defaultNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
bool isResourceDictionary = (document.Root.Name == XName.Get("ResourceDictionary", defaultNamespace.NamespaceName));
if (!isResourceDictionary)
{
fileDetails = new XAMLFileDetails(resourceName, document);
}
return(fileDetails);
}
public static T LoadBaml <T>(Stream stream)
{
//For .net 3.5:
//ParserContext parserContext = new ParserContext();
//object[] parameters = new object[] { stream, parserContext, null, false };
//object bamlRoot = LoadBamlMethod.Invoke(null, parameters);
//return (T)bamlRoot;
//For .net 4.0
var reader = new Baml2006Reader(stream);
var substream = reader.Value as MemoryStream;
if (substream != null)
{
using (var subReader = CreateBamlFragmentReader(substream, reader.SchemaContext))
{
var writer = new XamlObjectWriter(subReader.SchemaContext);
while (subReader.Read())
{
writer.WriteNode(subReader);
}
return((T)writer.Result);
}
}
else
{
var writer = new XamlObjectWriter(reader.SchemaContext);
while (reader.Read())
{
writer.WriteNode(reader);
}
return((T)writer.Result);
}
}
private static Style ReadDefaultStyle(Type type)
{
var assembly = type.Assembly;
using (var resourceReader = new ResourceReader(assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().Single())))
{
foreach (DictionaryEntry entry in resourceReader)
{
using (var reader = new Baml2006Reader((Stream)entry.Value))
{
using (var writer = new XamlObjectWriter(reader.SchemaContext))
{
while (reader.Read())
{
writer.WriteNode(reader);
}
var resourceDictionary = (ResourceDictionary)writer.Result;
if (resourceDictionary.Contains(type))
{
return((Style)resourceDictionary[type]);
}
}
}
}
}
throw new ArgumentOutOfRangeException();
}
private static T ReadBaml <T>(Stream stream)
{
var bamlReader = new Baml2006Reader(stream);
var writer = new XamlObjectWriter(bamlReader.SchemaContext);
while (bamlReader.Read())
{
writer.WriteNode(bamlReader);
}
return((T)writer.Result);
}
/// <summary>
/// Load xaml resource stream
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static object Load(Stream stream)
{
var reader = new Baml2006Reader(stream);
var writer = new XamlObjectWriter(reader.SchemaContext);
while (reader.Read())
{
writer.WriteNode(reader);
}
return(writer.Result);
}
/// <summary>Loads the baml.</summary>
/// <typeparam name="TRoot">The type of the root.</typeparam>
/// <param name="stream">The <paramref name="stream"/>.</param>
/// <returns>the loaded <see langword="object"/> parameter</returns>
/// <exception cref="ArgumentNullException"><paramref>
/// <name>reader</name>
/// </paramref>
/// is null.</exception>
/// <exception cref="NotImplementedException">The default implementation encountered a <see cref="T:System.Xaml.XamlNodeType" /> that is not in the default enumeration.</exception>
internal static TRoot LoadBaml <TRoot>(Stream stream)
{
var reader = new Baml2006Reader(stream);
var writer = new XamlObjectWriter(reader.SchemaContext);
while (reader.Read())
{
writer.WriteNode(reader);
}
return((TRoot)writer.Result);
}
private static ResourceDictionary CreateEmptyResourceDictionaryInstance(Uri uri)
{
try
{
var streamInfo = Application.GetResourceStream(RebuildBamlUri(uri));
if (streamInfo == null)
{
return(null);
}
#if !SILVERLIGHT
if (IsBamlResource(uri))
{
using (var bamlReader = new Baml2006Reader(streamInfo.Stream))
{
while (bamlReader.Read())
{
if (bamlReader.NodeType != XamlNodeType.StartObject)
{
continue;
}
if (bamlReader.Type == null)
{
return(null);
}
var objectType = bamlReader.Type.UnderlyingType;
if (objectType == typeof(ResourceDictionary) || objectType.IsSubclassOf(typeof(ResourceDictionary)))
{
return((ResourceDictionary)Activator.CreateInstance(objectType));
}
}
}
return(null);
}
#endif
using (var streamReader = new StreamReader(streamInfo.Stream, Encoding.UTF8))
return(GetResourceDictionary(XElement.Parse(streamReader.ReadToEnd()).Name));
}
catch (Exception e)
{
LogService.LogError(e);
}
return(null);
}
public string OneBigString()
{
StringBuilder sb = new StringBuilder();
try
{
while (_bamlReader.Read())
{
_displayWriter.WriteNode(_bamlReader);
sb.AppendLine(_displayWriter.CurrentIndentedNodeText);
}
}
catch (Exception ex)
{
sb.AppendLine(ex.ToString());
}
return(sb.ToString());
}
private void ScanPages()
{
// KsWare.Presentation.UITestApp.g.resources
var asm = Assembly.GetEntryAssembly();
var resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream)) {
var resources = reader.Cast <DictionaryEntry>().Select(entry => (string)entry.Key).ToArray();
foreach (var resource in resources)
{
if (!resource.StartsWith("pages/"))
{
continue;
}
var uri = new Uri(resource.Substring(0, resource.Length - 5) + ".xaml", UriKind.Relative);
var restream = Application.GetResourceStream(uri).Stream;
var bamlReader = new Baml2006Reader(restream);
var writer = new XamlObjectWriter(bamlReader.SchemaContext);
try {
while (bamlReader.Read())
{
writer.WriteNode(bamlReader);
}
}
catch (Exception ex) {
var lineInfo = (IXamlLineInfo)bamlReader;
Debug.WriteLine($"Error loading {resource}: {lineInfo.LineNumber},{lineInfo.LinePosition}. Message: {ex.Message}");
MessageBox.Show($"Error loading {resource}: {lineInfo.LineNumber},{lineInfo.LinePosition}. \nMessage: \n{ex.Message}", "Error");
continue;
}
var xamlObject = writer.Result;
var name = xamlObject.GetType().Name;
Pages.Add(new PageInfoVM()
{
DisplayName = name,
Uri = uri,
View = (FrameworkElement)xamlObject
});
}
}
}
public string OneBigString()
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings xmlSettings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
OmitXmlDeclaration = true
};
XmlWriter xmlWriter = XmlWriter.Create(sb, xmlSettings);
_xamlWriter = new XamlXmlWriter(xmlWriter, _bamlReader.SchemaContext);
while (_bamlReader.Read())
{
_xamlWriter.WriteNode(_bamlReader);
}
xmlWriter.Flush();
xmlWriter.Close();
return(sb.ToString());
}
private BamlControl LoadBaml(string name)
{
if (assembly == null)
{
assembly = Assembly.GetCallingAssembly();
}
if (assemblyName == "")
{
assemblyName = Language.GetAssemblyName(Assembly.GetCallingAssembly());
}
string language = Language.Id;
if (language == "")
{
language = Thread.CurrentThread.CurrentUICulture.ToString();
}
string bamlName = name.ToLower() + ".baml";
// Get the name of g-resource
string resourceName = assemblyName + ".g";
if ((language != "") && (language != Language.OriginalId))
{
resourceName = resourceName + "." + language;
}
resourceName = resourceName + ".resources";
Stream stream = assembly.GetManifestResourceStream(resourceName);
BamlControl current = null;
using (var resourceReader = new ResourceReader(stream))
{
foreach (DictionaryEntry entry in resourceReader)
{
if (entry.Key.ToString() == bamlName)
{
Stream bamlStream = entry.Value as Stream;
var bamlReader = new Baml2006Reader(bamlStream);
string memberName = "";
var baml = new BamlControl();
current = null;
while (bamlReader.Read())
{
XamlNodeType nodeType = bamlReader.NodeType;
switch (bamlReader.NodeType)
{
case XamlNodeType.StartObject:
if (current == null)
{
current = baml;
}
else
{
current = current.Add(new BamlControl());
}
if (bamlReader.Type != null)
{
current.ElementName = bamlReader.Type.ToString();
}
break;
case XamlNodeType.GetObject:
current = current.Add(new BamlControl());
current.MemberName = memberName;
break;
case XamlNodeType.EndObject:
if (current != null)
{
current = current.Parent;
}
break;
case XamlNodeType.StartMember:
memberName = bamlReader.Member.Name;
break;
case XamlNodeType.EndMember:
memberName = "";
break;
case XamlNodeType.Value:
if (memberName == "Name")
{
current.Name = bamlReader.Value.ToString();
}
else if (memberName == "Uid")
{
current.Uid = bamlReader.Value.ToString();
}
else if (memberName == "Content")
{
current.Value = bamlReader.Value;
}
else if (memberName != "")
{
current.AddProperty(memberName, bamlReader.Value);
}
break;
}
}
return(baml);
}
}
}
return(null);
}
public string DecompileBaml(MemoryStream bamlCode, string containingAssemblyFile)
{
bamlCode.Position = 0;
TextWriter w = new StringWriter();
Assembly assembly = Assembly.LoadFile(containingAssemblyFile);
Baml2006Reader reader = new Baml2006Reader(bamlCode, new XamlReaderSettings()
{
ValuesMustBeString = true, LocalAssembly = assembly
});
XDocument doc = new XDocument();
XamlXmlWriter writer = new XamlXmlWriter(doc.CreateWriter(), reader.SchemaContext);
while (reader.Read())
{
switch (reader.NodeType)
{
case XamlNodeType.None:
break;
case XamlNodeType.StartObject:
writer.WriteStartObject(reader.Type);
break;
case XamlNodeType.GetObject:
writer.WriteGetObject();
break;
case XamlNodeType.EndObject:
writer.WriteEndObject();
break;
case XamlNodeType.StartMember:
writer.WriteStartMember(reader.Member);
break;
case XamlNodeType.EndMember:
writer.WriteEndMember();
break;
case XamlNodeType.Value:
// requires XamlReaderSettings.ValuesMustBeString = true to work properly
writer.WriteValue(reader.Value);
break;
case XamlNodeType.NamespaceDeclaration:
writer.WriteNamespace(reader.Namespace);
break;
default:
throw new Exception("Invalid value for XamlNodeType");
}
}
writer.Close();
// Fix namespace references
string suffixToRemove = ";assembly=" + assembly.GetName().Name;
foreach (XAttribute attrib in doc.Root.Attributes())
{
if (attrib.Name.Namespace == XNamespace.Xmlns)
{
if (attrib.Value.EndsWith(suffixToRemove, StringComparison.Ordinal))
{
string newNamespace = attrib.Value.Substring(0, attrib.Value.Length - suffixToRemove.Length);
ChangeXmlNamespace(doc, attrib.Value, newNamespace);
attrib.Value = newNamespace;
}
}
}
// Convert x:Key into an attribute where possible
XName xKey = XName.Get("Key", "http://schemas.microsoft.com/winfx/2006/xaml");
foreach (XElement e in doc.Descendants(xKey).ToList())
{
if (e.Nodes().Count() != 1)
{
continue;
}
XText text = e.Nodes().Single() as XText;
if (text != null)
{
e.Parent.SetAttributeValue(xKey, text.Value);
e.Remove();
}
}
return(doc.ToString());
}
static void Main(string[] args)
{
XmlConfigurator.Configure();
string oldFolder = @"C:\";
string newFolder = @"C:\";
DirectoryInfo oldDi = new DirectoryInfo(oldFolder);
DirectoryInfo newDi = new DirectoryInfo(newFolder);
if (oldDi.Exists && newDi.Exists)
{
FileInfo[] oldGenDll = oldDi.GetFiles(FILTER);
FileInfo[] newGenDll = newDi.GetFiles(FILTER);
if (oldGenDll.Length != newGenDll.Length)
{
log.Info(string.Format("oldGenDll.Length = {0}, newGenDll.Length = {1}", oldGenDll.Length, newGenDll.Length));
// Compare names:
throw new NotImplementedException();
}
foreach (FileInfo fiOld in oldGenDll)
{
FileInfo fiNew = newGenDll.Where(t => t.Name.Equals(fiOld.Name)).FirstOrDefault();
ModuleDefinition oldModule = ModuleDefinition.ReadModule(fiOld.FullName);
var oldTypes = oldModule.Types;
ModuleDefinition newModule = ModuleDefinition.ReadModule(fiNew.FullName);
var newTypes = newModule.Types;
if (oldTypes.Count != newTypes.Count)
{
Append2Dictionary(fiOld.Name, string.Format("oldTypes.Count = {0}, newTypes.Count = {1}", oldTypes.Count, newTypes.Count));
// Compare names:
var oldNames = oldTypes.Select(t => t.Name).ToList();
var newNames = newTypes.Select(t => t.Name).ToList();
CompareNames(fiOld.Name, oldNames, newNames, "Types Added", "Types Removed");
}
foreach (TypeDefinition oldType in oldTypes)
{
if (!oldType.IsInterface && !IsClassImplementInterfaceInList(oldType, MyInterfaces))
{
continue;
}
TypeDefinition newType = newTypes.Where(t => t.Name.Equals(oldType.Name)).FirstOrDefault();
if (newType == null)
{
continue;
}
//if (!MyInterfaces.Contains(oldType.Name))
// continue;
var allOldMethods = oldType.Methods;
var allnewMethods = newType.Methods;
if (allOldMethods.Count != allnewMethods.Count)
{
Append2Dictionary(oldType.Name, string.Format("allOldMethods.Count = {0}, allnewMethods.Count = {1}", allOldMethods.Count, allnewMethods.Count));
// Compare names:
var oldNames = allOldMethods.Select(t => t.Name).ToList();
var newNames = allnewMethods.Select(t => t.Name).ToList();
CompareNames(oldType.Name, oldNames, newNames, "Methods Added", "Methods Removed");
}
foreach (MethodDefinition oldMdef in allOldMethods)
{
MethodDefinition newMdef = allnewMethods.Where(t => t.Name.Equals(oldMdef.Name)).FirstOrDefault();
if (newMdef == null)
{
continue;
}
string cSharpCodeDisAssembOld = getSourceCode(oldMdef);
if (string.IsNullOrWhiteSpace(cSharpCodeDisAssembOld))
{
continue;
}
string cSharpCodeDisAssembNew = getSourceCode(newMdef);
if (cSharpCodeDisAssembOld != cSharpCodeDisAssembNew)
{
Append2Dictionary(oldType.Name, TAB + oldMdef.Name + " are differents.");
}
}
}
// xaml
if (oldModule.Resources.Count > 0)
{
EmbeddedResource rOld = (EmbeddedResource)oldModule.Resources.Where(r => r.Name.Contains(".g.")).FirstOrDefault();
ResourceReader readerOld = null;
using (var stream = rOld.GetResourceStream())
{
using (readerOld = new ResourceReader(stream))
{
EmbeddedResource rNew = (EmbeddedResource)newModule.Resources.Where(r => r.Name.Contains(".g.")).FirstOrDefault();
ResourceReader readerNew = null;
using (var stream2 = rNew.GetResourceStream())
{
using (readerNew = new ResourceReader(stream2))
{
foreach (DictionaryEntry entry in readerOld)
{
///Read the values in the entry
if (!entry.Key.ToString().Contains(BAML_EXTENSION))
{
continue;
}
string fullName = entry.Key.ToString();
int indexOfLastSlash = fullName.LastIndexOf(@"/");
int indexOfDotBaml = fullName.IndexOf(BAML_EXTENSION);
string className = entry.Key.ToString().Substring(indexOfLastSlash + 1, indexOfDotBaml - indexOfLastSlash - 1);
var classOfThisBaml = oldTypes.Where(t => t.Name.ToLower().Equals(className)).FirstOrDefault();
if (classOfThisBaml == null || (!classOfThisBaml.IsInterface && !IsClassImplementInterfaceInList(classOfThisBaml, MyInterfaces)))
{
continue;
}
//var newClassOfThisBaml = newTypes.Where(t => t.Name.ToLower().Equals(className)).FirstOrDefault();
System.IO.MemoryStream codeofOldBaml = entry.Value as MemoryStream;
string oldCode = string.Empty;
using (StreamReader oldStreamR = new StreamReader(codeofOldBaml as Stream, Encoding.UTF8))
{
oldCode = oldStreamR.ReadToEnd();
oldStreamR.Close();
}
Baml2006Reader reader = new Baml2006Reader(codeofOldBaml as Stream);
while (!reader.IsEof)
{
var noeud = reader.Value;
reader.Read();
}
//var writer = new XamlObjectWriter(reader.SchemaContext);
//while (reader.Read())
// writer.WriteNode(reader);
string typeofNewBaml = string.Empty;
byte[] codeofNewBaml = null;
readerNew.GetResourceData(fullName, out typeofNewBaml, out codeofNewBaml);
// en fait le baml est un code précompilé, reste à trouver comment le décompiler en xaml
string newcode = Encoding.UTF8.GetString(codeofNewBaml);
}
stream2.Close();
}
readerNew.Close();
}
}
readerOld.Close();
stream.Close();
}
}
// print
//if (bufferInfo.Count > 1)
{
foreach (var item in bufferInfo)
{
log.Info(item.Key);
foreach (var line in item.Value)
{
log.Info(line);
}
}
if (bufferInfo.Count > 0)
{
NewLine();
}
}
bufferInfo.Clear();
}
}
}
