public void TestCtor()
{
var asmFullNameWithProcArch =
"log4net, Version=1.2.13.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL";
var asmFullName =
"log4net, Version=1.2.13.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a";
var classAsmQualifiedName =
"NoFuture.MyDatabase.Dbo.AccountExecutives, NoFuture.MyDatabase, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null";
var nsClassName = "NoFuture.Util.TypeName";
var testOne = new NfTypeName(asmFullNameWithProcArch);
var testTwo = new NfTypeName(asmFullName);
var testThree = new NfTypeName(classAsmQualifiedName);
var testFour = new NfTypeName(nsClassName);
Console.WriteLine(testOne.AssemblyQualifiedName);
Assert.IsTrue(string.IsNullOrWhiteSpace(testOne.AssemblyQualifiedName));
Assert.IsTrue(string.IsNullOrWhiteSpace(testTwo.AssemblyQualifiedName));
Assert.AreEqual(classAsmQualifiedName, testThree.AssemblyQualifiedName);
Assert.IsTrue(string.IsNullOrWhiteSpace(testFour.AssemblyQualifiedName));
Assert.AreEqual("log4net", testOne.AssemblySimpleName);
Assert.AreEqual("log4net", testTwo.AssemblySimpleName);
Assert.AreEqual("NoFuture.MyDatabase", testThree.AssemblySimpleName);
Assert.AreEqual(nsClassName, testFour.AssemblySimpleName);
Assert.AreEqual(asmFullName, testTwo.AssemblyFullName);
Assert.AreEqual("NoFuture.MyDatabase, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", testThree.AssemblyFullName);
var testFive =
new NfTypeName(
"NoFuture.CRM.UI.Controller, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
Assert.AreEqual("NoFuture.CRM.UI.Controller.dll", testFive.AssemblyFileName);
testThree =
new NfTypeName(
"NoFuture.MyDatabase.Dbo.AccountExecutives, NoFuture.MyDatabase, Version=0.0.0.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a");
Console.WriteLine($"Original String: '{testThree.RawString}'");
Assert.AreEqual("NoFuture.MyDatabase.dll", testThree.AssemblyFileName);
Assert.AreEqual("NoFuture.MyDatabase, Version=0.0.0.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a", testThree.AssemblyFullName);
Assert.AreEqual("NoFuture.MyDatabase", testThree.AssemblySimpleName);
Assert.AreEqual(testThree.RawString, testThree.AssemblyQualifiedName);
Assert.AreEqual("AccountExecutives", testThree.ClassName);
Assert.AreEqual("NoFuture.MyDatabase.Dbo.AccountExecutives", testThree.FullName);
Assert.AreEqual("NoFuture.MyDatabase.Dbo", testThree.Namespace);
Assert.AreEqual("Version=0.0.0.0", testThree.Version);
Assert.AreEqual("PublicKeyToken=669e0ddf0bb1aa2a", testThree.PublicKeyToken);
Assert.AreEqual("Culture=neutral", testThree.Culture);
var testSix = new NfTypeName("My_SillyName_NoNamespace_Pos_Class");
Assert.AreEqual("My_SillyName_NoNamespace_Pos_Class", testSix.ClassName);
}
public static string ManyToOnePropertyName(string fullAssemblyQualTypeName, string[] fkColumnNames)
{
var fkPropertyType = new NfTypeName(fullAssemblyQualTypeName);
var fkPropertyName = fkPropertyType.ClassName;
fkColumnNames = fkColumnNames.Select(x => NfString.CapWords(NfString.ExtractLastWholeWord(x, '.'), null)).ToArray();
return(string.Format("{0}By{1}", fkPropertyName,
string.Join("And", fkColumnNames)));
}
public static string HbmFileNameFromAsmQualTypeName(string asmFullName, bool prependDir = false)
{
if (string.IsNullOrWhiteSpace(asmFullName) || !NfReflect.IsFullAssemblyQualTypeName(asmFullName))
{
return(HbmFileName(asmFullName));
}
var nfName = new NfTypeName(asmFullName);
var tbl = nfName.Namespace.Replace($"{nfName.AssemblySimpleName}.", string.Empty) + "." + nfName.ClassName;
var flNm = HbmFileName(tbl);
return(prependDir ? Path.Combine(Settings.HbmDirectory, flNm) : flNm);
}
public static string ClassName(string name, string outputNamespace)
{
var asmQualifiedName = new StringBuilder();
if (name.Split(Shared.Core.NfSettings.DefaultTypeSeparator).Length > 1)
{
var nameParts = name.Split(Shared.Core.NfSettings.DefaultTypeSeparator);
var actualClassName = nameParts[(nameParts.Length - 1)].Replace(" ", Globals.REPLACE_SPACE_WITH_SEQUENCE);
nameParts[(nameParts.Length - 1)] = NfString.SafeDotNetTypeName(actualClassName);
name = string.Join(Shared.Core.NfSettings.DefaultTypeSeparator.ToString(CultureInfo.InvariantCulture), nameParts);
}
//remove any chars not allowed in C# ids
name = NfString.SafeDotNetTypeName(name);
//capitalize first letter of whole word to avoid conflict with C# reserved words
name = NfString.CapWords(name, Shared.Core.NfSettings.DefaultTypeSeparator);
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
outputNamespace = NfString.CapWords(outputNamespace, Shared.Core.NfSettings.DefaultTypeSeparator);
asmQualifiedName.AppendFormat("{0}{1}", outputNamespace, Shared.Core.NfSettings.DefaultTypeSeparator);
}
asmQualifiedName.Append(name);
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
asmQualifiedName.AppendFormat(", {0}", NfReflect.DraftCscExeAsmName(outputNamespace));
}
var typeName = new NfTypeName(asmQualifiedName.ToString());
if (!String.IsNullOrWhiteSpace(outputNamespace))
{
return(typeName.AssemblyQualifiedName);
}
return(typeName.FullName);
}
public static string BagPropertyName(string fullAssemblyQualTypeName)
{
var pluralBagName = new NfTypeName(fullAssemblyQualTypeName);
return(Gen.Etc.ToPlural(pluralBagName.ClassName, true));
}
/// <summary>
/// During the generation process of hbm.xml files from the various JSON metadata, it
/// is possiable that the names of properties may be duplicated and\or the name of
/// properties match their class name.
/// This function is intended to handle all such circumstances and correct them as needed
/// appending a '00', '01' ,'02', etc. to the ends of duplicate names.
/// </summary>
/// <param name="hbmXmlOutputPath">
/// This file must already exist on disk and, upon duplicates being found, is overwritten with the corrected contents.
/// </param>
/// <param name="storedProcRules">
/// Set this flag to true if the <see cref="hbmXmlOutputPath"/>
/// is working a file with contains any 'return-property' nodes (typically present on
/// sql-query nodes).
/// </param>
/// <remarks>
/// This function will, in theory, work for any hbm.xml file which is of the xmlns <see cref="Globals.HBM_XML_NS"/>
/// but was designed only for hbm.xml files generated herein.
/// </remarks>
public static void CorrectHbmXmlDuplicateNames(string hbmXmlOutputPath, bool storedProcRules = false)
{
if (!File.Exists(hbmXmlOutputPath))
{
return;
}
var overwriteFlag = false;
var hbmXml = new XmlDocument();
hbmXml.Load(hbmXmlOutputPath);
var nsMgr = new XmlNamespaceManager(hbmXml.NameTable);
nsMgr.AddNamespace("nhib", Globals.HBM_XML_NS);
var hbmClassNode = hbmXml.SelectSingleNode("//nhib:class", nsMgr);
if (hbmClassNode == null || hbmClassNode.Attributes == null)
{
throw new InvalidHbmNameException(
string.Format(
"Xml file at '{0}' either does not have a node named 'class' or the 'class' node has no attributes.",
hbmXmlOutputPath));
}
var hbmClassName = hbmClassNode.Attributes["name"].Value;
var hbmTypeName = new NfTypeName(hbmClassName);
hbmClassName = hbmTypeName.ClassName;
var propertyNames = new List <string>();
var keyPropertyNames = new List <string>();
var keyMtoPropertyNames = new List <string>();
var returnPropNames = new List <string>();
var propertyNodes = hbmXml.SelectNodes("//nhib:property", nsMgr);
var manyToOneNodes = hbmXml.SelectNodes("//nhib:many-to-one", nsMgr);
var bagNodes = hbmXml.SelectNodes("//nhib:bag", nsMgr);
var keyPropertyNodes = hbmXml.SelectNodes("//nhib:key-property", nsMgr);
var keyMtoPropertyNodes = hbmXml.SelectNodes("//nhib:key-many-to-one", nsMgr);
var returnPropNodes = hbmXml.SelectNodes("//nhib:return-property", nsMgr);
propertyNames.Add("Id");
if (propertyNodes != null)
{
propertyNames.AddRange(from XmlNode propNode in propertyNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
if (manyToOneNodes != null)
{
propertyNames.AddRange(from XmlNode propNode in manyToOneNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
if (bagNodes != null)
{
propertyNames.AddRange(from XmlNode propNode in bagNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
if (keyPropertyNodes != null)
{
keyPropertyNames.AddRange(from XmlNode propNode in keyPropertyNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
if (keyMtoPropertyNodes != null)
{
keyMtoPropertyNames.AddRange(from XmlNode propNode in keyMtoPropertyNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
if (returnPropNodes != null)
{
returnPropNames.AddRange(from XmlNode propNode in returnPropNodes
where propNode.Attributes != null && propNode.Attributes["name"] != null
select propNode.Attributes["name"].Value);
}
//acid test for duplicate names
var dupPropOverwriteFlag = storedProcRules
? AcidTestDuplicateNames(hbmXmlOutputPath, propertyNames, hbmXml, nsMgr, "property")
: AcidTestDuplicateNames(hbmXmlOutputPath, propertyNames, hbmXml, nsMgr);
var dupKeyPropOverwriteFlag = AcidTestDuplicateNames(hbmXmlOutputPath, keyPropertyNames, hbmXml, nsMgr,
"key-property");
var dubMtoKeyPropOverwriteFlag = AcidTestDuplicateNames(hbmXmlOutputPath, keyMtoPropertyNames, hbmXml, nsMgr,
"key-many-to-one");
var dupReturnPropFlag = storedProcRules &&
AcidTestDuplicateNames(hbmXmlOutputPath, returnPropNames, hbmXml, nsMgr,
"return-property");
overwriteFlag = dupKeyPropOverwriteFlag || dupPropOverwriteFlag || dubMtoKeyPropOverwriteFlag ||
dupReturnPropFlag;
if (propertyNames.Contains(hbmClassName))
{
var pnNodes = hbmXml.SelectNodes(string.Format("//nhib:*[@name='{0}']", hbmClassName), nsMgr);
if (pnNodes == null)
{
throw new ItsDeadJim(
string.Format(
"Property names which match the class name '{0}' are supposed to be present but an XPath selector returned null",
hbmClassName));
}
for (var i = 0; i < pnNodes.Count; i++)
{
overwriteFlag = true;
if (pnNodes[i] == null || pnNodes[i].Attributes == null ||
pnNodes[i].Attributes["name"] == null)
{
continue;
}
pnNodes[i].Attributes["name"].Value = string.Format("{0}{1:00}", hbmClassName, i);
}
Console.WriteLine("{0:yyyy-MM-dd HH:mm:ss.ffff}'{1}' duplicate property [{2}]", DateTime.Now,
hbmXmlOutputPath, hbmClassName);
}
if (!overwriteFlag)
{
return;
}
using (var myXmlWriter = new XmlTextWriter(hbmXmlOutputPath, System.Text.Encoding.UTF8)
{
Formatting = Formatting.Indented
})
{
hbmXml.WriteContentTo(myXmlWriter);
myXmlWriter.Flush();
}
}
protected static void GetFksWhichAreNotPartOfPks(string outputNamespace, string tbl, Dictionary <string, FkItem> hbmFk, XElement classXe)
{
//----fks which are not part of pks
if (!hbmFk.ContainsKey(tbl))
{
return;
}
var tblFks = hbmFk[tbl].ManyToOne;
foreach (var fkName in tblFks.Keys)
{
//these would be FK ref to another type but its underlying table is excluded so now its just a bunch of value types
if (Settings.DoNotReference.Contains(fkName))
{
foreach (var reducedFk in tblFks[fkName])
{
var reducedFkSimpProp = GetSimplePropertyHbmXml(reducedFk,
Globals.HbmXmlNames.PROPERTY);
classXe.Add(reducedFkSimpProp);
}
continue; //these need representation but not as class types
}
var manytoOneColumns = new List <ColumnMetadata>();
if (!HbmOneToMany.GetManyToOneColumns(tbl, ref manytoOneColumns))
{
continue;
}
var fkColumnsByDistinctConstraintName = manytoOneColumns.Select(x => x.constraint_name).Distinct().ToList();
foreach (var distinctConstraintName in fkColumnsByDistinctConstraintName)
{
var dMtoColumnData = tblFks[fkName].Where(
x =>
string.Equals(x.constraint_name, distinctConstraintName, Sorting.C)).ToList();
if (dMtoColumnData.Count <= 0)
{
continue;
}
var fkColumnXes = new List <XElement>();
var fkColumnNames = new List <string>();
foreach (var x in dMtoColumnData)
{
x.CopyFrom(Sorting.GetFromAllColumnMetadata(x));
var fullColumnName = x.column_name;
Compose.ValidSplit(fullColumnName, 3);
var cn = NfString.ExtractLastWholeWord(fullColumnName, null);
//need to store these temp, since we are also drafting thier parent's name
fkColumnXes.Add(XeFactory.ColumnNode(cn, x.ToJsonString()));
fkColumnNames.Add(cn);
}
var fkPropertyType = new NfTypeName(Compose.ClassName(fkName, outputNamespace));
var fkPropertyName = Compose.ManyToOnePropertyName(Compose.ClassName(fkName, outputNamespace),
fkColumnNames.ToArray());
var manyToOneXe = XeFactory.ManyToOneNode(fkPropertyName, fkPropertyType.AssemblyQualifiedName);
foreach (var fkXe in fkColumnXes)
{
manyToOneXe.Add(fkXe);
}
classXe.Add(manyToOneXe);
}
}
}
protected static bool GetPk(string outputNamespace, string tbl, Dictionary <string, PkItem> hbmPk, XElement classXe)
{
//----PK
var pkId = hbmPk.ContainsKey(tbl) ? hbmPk[tbl].Id : null;
var hasNoPkAtAll = !hbmPk.ContainsKey(tbl);
if (pkId == null && !hasNoPkAtAll)
{
var compClassName = Compose.CompKeyClassName(tbl, outputNamespace);
const string compPropertyName = Globals.HbmXmlNames.ID;
var compKeyXe = XeFactory.CompositeIdNode(compPropertyName, compClassName);
//key-many-to-one
var hbmKeyManyToOne = hbmPk[tbl].KeyManyToOne ?? new Dictionary <string, List <ColumnMetadata> >();
if (hbmKeyManyToOne.Count > 0)
{
foreach (var keyname in hbmKeyManyToOne.Keys.Where(k => !Settings.DoNotReference.Contains(k)))
{
//need to iterate here on a per 'constraint_name', the json data-struct misses this
//eg a table, 4 columns; 2 are comp to another table's Pk and the other 2 are also a comp the SAME table's PK
var keyManytoOneColumns = new List <ColumnMetadata>();
if (!HbmKeys.GetKeyManyToOneColumns(tbl, ref keyManytoOneColumns))
{
continue;
}
foreach (var distinctColumn in keyManytoOneColumns.Distinct(new ConstraintNameComparer()))
{
var dKmtoCName = distinctColumn.constraint_name;
var keyMtoFullyQualTypeName = Compose.ClassName(keyname, outputNamespace);
var keyMtoNfTypeNameObj = new NfTypeName(keyMtoFullyQualTypeName);
var keyMtoSimpleName = keyMtoNfTypeNameObj.ClassName;
var keyMtoXe = XeFactory.KeyManyToOneNode(keyMtoSimpleName,
keyMtoFullyQualTypeName);
var dKmtoColumnData = hbmKeyManyToOne[keyname].Where(
x =>
string.Equals(x.constraint_name, dKmtoCName, Sorting.C)).ToList();
if (dKmtoColumnData.Count <= 0)
{
continue;
}
foreach (var kmtoColumn in dKmtoColumnData)
{
kmtoColumn.CopyFrom(Sorting.GetFromAllColumnMetadata(kmtoColumn));
var fullColumnName = kmtoColumn.column_name;
//not having the naming pattern is exceptional
Compose.ValidSplit(fullColumnName, 3);
var keyMtoColumnXe =
XeFactory.ColumnNode(NfString.ExtractLastWholeWord(fullColumnName, null),
kmtoColumn.ToJsonString());
keyMtoXe.Add(keyMtoColumnXe);
}
compKeyXe.Add(keyMtoXe);
} //end foreach distinct constraintname
}
} //end key-many-to-one
var hbmKeyProperty = hbmPk[tbl].KeyProperty ?? new Dictionary <string, List <ColumnMetadata> >();
//these would have been added as key-many-to-one, but thier underlying table has been excluded.
foreach (var reduced in hbmKeyManyToOne.Where(k => Settings.DoNotReference.Contains(k.Key)))
{
foreach (var redux in reduced.Value)
{
redux.CopyFrom(Sorting.GetFromAllColumnMetadata(redux));
}
//insure they got everything for being a value type
hbmKeyProperty.Add(reduced.Key, reduced.Value);
}
if (hbmKeyProperty.Count > 0)
{
//Dictionary<string, List<ColumnMetadata>>
foreach (var keyName in hbmKeyProperty.Keys)
{
//SPECIAL NOTE: the original PS code seemed to imply that a key-property is always just one column...
var keyPropJsonData = hbmKeyProperty[keyName].FirstOrDefault();
if (keyPropJsonData == null)
{
continue;
}
keyPropJsonData.CopyFrom(Sorting.GetFromAllColumnMetadata(keyPropJsonData));
var keyPropPropertyName = Compose.PropertyName(keyPropJsonData.column_name);
var fullcolumnName = keyPropJsonData.column_name;
Compose.ValidSplit(fullcolumnName, 3);
var keyPropDataType = Util.Lexicon.Mssql2HbmTypes[(keyPropJsonData.data_type)];
var keyPropColumn = NfString.ExtractLastWholeWord(fullcolumnName, null);
var keyPropLen = keyPropJsonData.string_length ?? Globals.MSSQL_MAX_VARCHAR;
if (string.Equals(keyPropDataType, Globals.HbmXmlNames.ANSI_STRING))
{
if (keyPropLen <= 0)
{
keyPropLen = Globals.MSSQL_MAX_VARCHAR;
}
var keyPropXe = XeFactory.KeyPropertyNode(keyPropPropertyName, keyPropColumn,
keyPropDataType, keyPropLen.ToString(CultureInfo.InvariantCulture),
keyPropJsonData.ToJsonString());
compKeyXe.Add(keyPropXe);
}
else
{
var keyPropXe = XeFactory.KeyPropertyNode(keyPropPropertyName, keyPropColumn,
keyPropDataType, keyPropJsonData.ToJsonString());
compKeyXe.Add(keyPropXe);
}
}
}
classXe.Add(compKeyXe);
}
else if (pkId != null)
{
GetSimpleId(pkId, classXe);
} //end PK
return(hasNoPkAtAll);
}
/// <summary>
/// Parses a hbm.xml file into this runtime equiv.
/// being intended for code generation.
/// </summary>
/// <param name="hbmXmlFilePath"></param>
public HbmFileContent(string hbmXmlFilePath)
{
_simpleProperties = new Dictionary <string, string>();
_fkProperties = new Dictionary <string, string>();
_listProperties = new Dictionary <string, string>();
_compositeKeyProperties = new Dictionary <string, string>();
_keyColumns = new Dictionary <string, ColumnMetadata>();
_simpleColumns = new Dictionary <string, ColumnMetadata>();
_fkColumns = new Dictionary <string, List <ColumnMetadata> >();
_listColumns = new Dictionary <string, List <ColumnMetadata> >();
_spConstNames = new List <HbmStoredProxNames>();
_keyManyToOnePropertyNames = new List <string>();
_allPkColumns = new Dictionary <string, string>();
if (!File.Exists(hbmXmlFilePath))
{
throw new ItsDeadJim(string.Format("There isn't any xml file at '{0}'", hbmXmlFilePath));
}
_fileNamePath = hbmXmlFilePath;
_hbmXml = new XmlDocument();
_hbmXml.LoadXml(File.ReadAllText(_fileNamePath));
_nsMgr = new XmlNamespaceManager(_hbmXml.NameTable);
_nsMgr.AddNamespace(NS, Globals.HBM_XML_NS);
_classNode =
_hbmXml.SelectSingleNode(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), _nsMgr) as
XmlElement;
if (_classNode == null)
{
throw new ItsDeadJim(string.Format("The top-level 'class' node is missing from the xml file at '{0}'", hbmXmlFilePath));
}
IsCompositeKey =
_hbmXml.SelectSingleNode(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS, HbmXmlNames.COMPOSITE_ID), _nsMgr) != null;
var tableNameAttr = _classNode.Attributes[HbmXmlNames.TABLE];
if (tableNameAttr != null)
{
_tableName = tableNameAttr.Value;
}
var attrTypeName = GetAttrVal(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), HbmXmlNames.NAME);
if (NfReflect.IsFullAssemblyQualTypeName(attrTypeName))
{
_asmQualTypeName = attrTypeName;
var nfName = new NfTypeName(attrTypeName);
_className = nfName.ClassName;
_namespace = nfName.Namespace;
}
else
{
_className = NfReflect.GetTypeNameWithoutNamespace(attrTypeName);
_namespace = NfReflect.GetNamespaceWithoutTypeName(attrTypeName);
_asmQualTypeName = Compose.ClassName(_className, _namespace);
}
_dbSchema = GetAttrVal(CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS), HbmXmlNames.SCHEMA);
//the stored prox will not have a schema qualifier so try to derive it from the file name
if (string.IsNullOrWhiteSpace(_dbSchema))
{
var ff = Path.GetFileName(_fileNamePath);
if (!string.IsNullOrWhiteSpace(ff) && ff.Split('.').Length > 3)
{
_dbSchema = ff.Split('.')[0];
}
else
{
_dbSchema = "Dbo";
}
}
//get id/composite-id node
GetIdNode();
//get id's name and type
GetIdName();
//get flat-data's names and types
GetFlatProperties();
//get FKs names and types
GetFkProperties();
//get IList names and types
GetListProperties();
//get stored proc names
GetStoredProcNames();
//get composite key's properties
GetCompositeKeyProperties();
//condense a list of what is just on this table
GetAllPkColumns();
}
/// <summary>
/// Converts the .NET type into the custom Code Gen type
/// </summary>
/// <param name="asmType"></param>
/// <param name="valueTypeOnly">
/// Will only export Fields and Properties whose base type extends System.ValueType
/// </param>
/// <param name="resolveDependencies">
/// Switch to have the IL of the type parsed and all dependent calls Metadata tokens added.
/// </param>
/// <returns></returns>
public static CgType GetCgOfType(this Type asmType, bool valueTypeOnly, bool resolveDependencies = false)
{
var cgType = new CgType();
if (asmType == null || NfReflect.IsIgnoreType(asmType) || NfReflect.IsClrGeneratedType(asmType))
{
return(null);
}
//use the logic in TypeName to get the namespace and class name so its not tied to having the assembly
var cgTypeName = new NfTypeName(asmType.AssemblyQualifiedName);
//make sure there is always some kind of namespace
cgType.Namespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? asmType.Assembly.GetName().Name
: cgTypeName.Namespace;
cgType.IsContrivedNamespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace);
cgType.Name = cgTypeName.ClassName;
cgType.AssemblyQualifiedName = asmType.AssemblyQualifiedName;
cgType.IsEnum = NfReflect.IsEnumType(asmType);
var cgTypesInterfaces = asmType.GetInterfaces();
cgType.MetadataToken = asmType.MetadataToken;
Func <CgType, string, bool> alreadyPresentHerein =
(cg, nextName) =>
(cg.Properties.FirstOrDefault(
cgP => string.Equals(cgP.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Fields.FirstOrDefault(
cgF => string.Equals(cgF.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Events.FirstOrDefault(
cgE => string.Equals(cgE.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null)
;
//have events go first since they tend to be speard across fields and properties
foreach (
var evtInfo in
asmType.GetEvents(Shared.Core.NfSettings.DefaultFlags))
{
var evtHandlerType = evtInfo.NfEventHandlerType().ToString();
var cgMem = new CgMember
{
Name = evtInfo.Name,
TypeName = evtHandlerType,
MetadataToken = evtInfo.MetadataToken
};
cgType.Events.Add(cgMem);
}
var asmMembers =
asmType.GetMembers(Shared.Core.NfSettings.DefaultFlags);
foreach (var mi in asmMembers)
{
if (alreadyPresentHerein(cgType, mi.Name))
{
continue;
}
try
{
if (mi.MemberType == MemberTypes.Property)
{
var pi = mi as PropertyInfo;
var cgm = GetAsCgMember(pi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
{
continue;
}
if (resolveDependencies)
{
var propMi = NfReflect.GetMethodsForProperty(pi, asmType);
foreach (var pim in propMi)
{
cgm.opCodeCallsAndCallvirtsMetadatTokens.AddRange(Asm.GetCallsMetadataTokens(pim));
}
}
cgType.Properties.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
{
throw;
}
cgType.Properties.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
HasGetter = true,
HasSetter = true,
SkipIt = true
});
}
try
{
if (mi.MemberType == MemberTypes.Event)
{
continue;//these have already been handled
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
continue;
}
try
{
if (mi.MemberType == MemberTypes.Field)
{
var fi = mi as FieldInfo;
var cgm = GetAsCgMember(fi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
{
continue;
}
cgType.Fields.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
{
throw;
}
cgType.Fields.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
try
{
if (!valueTypeOnly && mi.MemberType == MemberTypes.Method)
{
var mti = mi as MethodInfo;
var cgm = GetAsCgMember(mti, resolveDependencies);
if (cgm == null)
{
continue;
}
cgm.IsInterfaceImpl = IsInterfaceImpl(mti, cgTypesInterfaces);
cgType.Methods.Add(cgm);
}
if (!valueTypeOnly && mi.MemberType == MemberTypes.Constructor)
{
var ci = mi as ConstructorInfo;
var tn = (string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? cgTypeName.ClassName
: $"{cgTypeName.Namespace}.{cgTypeName.ClassName}");
var cgm = GetAsCgMember(ci, tn, resolveDependencies);
if (cgm == null)
{
continue;
}
cgType.Methods.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
{
throw;
}
cgType.Methods.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
}
if (resolveDependencies)
{
ResolveAllMetadataTokens(cgType, asmType.Assembly.ManifestModule);
}
return(cgType);
}
