public ClassCreator AddProperties(string propertyName, Type propertyType)
{
var backingField = new CodeMemberField(propertyType, "_" + propertyName);
_targetClass.Members.Add(backingField);
// Declare the read-only Width property.
var memberProperty = new CodeMemberProperty
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = propertyName,
HasGet = true,
HasSet = true,
Type = new CodeTypeReference(propertyType)
};
memberProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), "_" + propertyName)));
memberProperty.SetStatements.Add(
new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + propertyName),
new CodePropertySetValueReferenceExpression())
);
_targetClass.Members.Add(memberProperty);
return this;
}
private static void CreateAttributeConstForProperty(CodeTypeDeclaration type, CodeMemberProperty prop, HashSet<string> attributes)
{
var attributeLogicalName = (from CodeAttributeDeclaration att in prop.CustomAttributes
where att.AttributeType.BaseType == XrmAttributeLogicalName || HasAttributeAndRelationship(prop, att)
select new
{
FieldName = ((CodePrimitiveExpression)att.Arguments[0].Value).Value.ToString(),
Order = att.AttributeType.BaseType == XrmRelationshipSchemaName ? 0 : 1
}).
OrderBy(a => a.Order).
FirstOrDefault()?.FieldName;
if (attributes.Contains(prop.Name) || attributeLogicalName == null) return;
attributes.Add(prop.Name);
type.Members.Add(new CodeMemberField
{
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.Const,
Name = prop.Name,
Type = new CodeTypeReference(typeof (string)),
InitExpression = new CodePrimitiveExpression(attributeLogicalName)
});
}
protected override void ProcessProperty(CodeTypeDeclaration type, CodeMemberField field, CodeMemberProperty property)
{
if (property.Type.ArrayElementType == null) return; // Is array?
if (property.Name == "Items" || property.Name == "ItemsElementName") return;
CodeTypeReference genericType = new CodeTypeReference("System.Collections.Generic.List", new CodeTypeReference(property.Type.BaseType));
property.Type = genericType;
if (field != null) {
field.Type = genericType;
property.GetStatements.Insert(0,
// if
new CodeConditionStatement(
// field == null
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
// field = new List<T>();
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
new CodeObjectCreateExpression(genericType))));
}
}
public static CodeMemberProperty GenerateProperty(string propertyName, string propertyType, List<CodeStatement> getStatements = null, List<CodeStatement> setStatements = null)
{
CodeMemberProperty property = new CodeMemberProperty
{
Attributes = MemberAttributes.Family | MemberAttributes.Final,
Name = propertyName,
Type = GetTypeReferenceFromName(propertyType),
HasGet = (getStatements != null && getStatements.Any()),
HasSet = (setStatements != null && setStatements.Any())
};
if (property.HasGet && getStatements != null)
{
foreach (CodeStatement statement in getStatements)
{
property.GetStatements.Add(statement);
}
}
if (property.HasSet && setStatements != null)
{
foreach (CodeStatement statement in setStatements)
{
property.SetStatements.Add(statement);
}
}
return property;
}
public void EmitImplementationCode (CodeTypeDeclaration ctd)
{
byte[] bytes = Hash;
int hash = 0;
for (int i = 0; bytes.Length - i > 3; i += 4)
hash ^= BitConverter.ToInt32 (bytes, i);
// Insane Clown Property
CodeMemberProperty icp = new CodeMemberProperty ();
icp.Name = "ImplementationCode";
icp.Attributes = MemberAttributes.Family | MemberAttributes.Override;
icp.Type = new CodeTypeReference (typeof (int));
icp.HasGet = true;
icp.HasSet = false;
// get { return base.ImplementationCode ^ [number] }
// becomes:
// get { return LameCodeDomXor (base.ImplementationCode, [number]); }
CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression ();
invoke.Method = new CodeMethodReferenceExpression (CDH.This, "LameCodeDomXor");
invoke.Parameters.Add (new CodePropertyReferenceExpression (CDH.Base, "ImplementationCode"));
invoke.Parameters.Add (new CodePrimitiveExpression (hash));
icp.GetStatements.Add (new CodeMethodReturnStatement (invoke));
ctd.Members.Add (icp);
}
protected internal override void CreateMethods ()
{
CodeMemberField fld;
CodeMemberProperty prop;
/* override the following abstract PageTheme properties:
protected abstract string AppRelativeTemplateSourceDirectory { get; }
protected abstract IDictionary ControlSkins { get; }
protected abstract string[] LinkedStyleSheets { get; }
*/
/* ControlSkins */
fld = new CodeMemberField (typeof (HybridDictionary), "__controlSkins");
fld.Attributes = MemberAttributes.Private;
fld.InitExpression = new CodeObjectCreateExpression (typeof (HybridDictionary));
mainClass.Members.Add (fld);
prop = new CodeMemberProperty ();
prop.Name = "ControlSkins";
prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
prop.Type = new CodeTypeReference (typeof (IDictionary));
prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("__controlSkins")));
mainClass.Members.Add (prop);
/* LinkedStyleSheets */
fld = new CodeMemberField (typeof (string[]), "__linkedStyleSheets");
fld.Attributes = MemberAttributes.Private;
fld.InitExpression = CreateLinkedStyleSheets ();
mainClass.Members.Add (fld);
prop = new CodeMemberProperty ();
prop.Name = "LinkedStyleSheets";
prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
prop.Type = new CodeTypeReference (typeof (string[]));
prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("__linkedStyleSheets")));
mainClass.Members.Add (prop);
/* AppRelativeTemplateSourceDirectory */
prop = new CodeMemberProperty ();
prop.Name = "AppRelativeTemplateSourceDirectory";
prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
prop.Type = new CodeTypeReference (typeof (string));
prop.GetStatements.Add (new CodeMethodReturnStatement (
new CodePrimitiveExpression (
VirtualPathUtility.ToAbsolute (parser.BaseVirtualDir))));
mainClass.Members.Add (prop);
ControlBuilder builder = parser.RootBuilder;
if (builder.Children != null) {
foreach (object o in builder.Children) {
if (! (o is ControlBuilder))
continue;
if (o is CodeRenderBuilder)
continue;
ControlBuilder b = (ControlBuilder) o;
CreateControlSkinMethod (b);
}
}
}
private static void AddCommentsToFieldProperty(CodeMemberProperty property, ITemplateFieldInfo field)
{
if (!string.IsNullOrEmpty(field.HelpText))
property.Comments.Add(new CodeCommentStatement("<summary>" + field.HelpText + "</summary>", true));
else
property.Comments.Add(new CodeCommentStatement(string.Format("<summary>Represents the {0} field</summary>", field.DisplayName), true));
}
private void AddPropertyGroup(AssemblyBuilder assemblyBuilder, string groupName, string propertyNames, Hashtable properties, CodeTypeDeclaration type, CodeNamespace ns)
{
CodeMemberProperty property = new CodeMemberProperty {
Name = groupName,
Attributes = MemberAttributes.Public,
HasGet = true,
Type = new CodeTypeReference("ProfileGroup" + groupName)
};
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "GetProfileGroup" }
};
expression.Parameters.Add(new CodePrimitiveExpression(property.Name));
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(new CodeCastExpression(property.Type, expression));
property.GetStatements.Add(statement);
type.Members.Add(property);
CodeTypeDeclaration declaration = new CodeTypeDeclaration {
Name = "ProfileGroup" + groupName
};
declaration.BaseTypes.Add(new CodeTypeReference(typeof(ProfileGroupBase)));
foreach (string str in propertyNames.Split(new char[] { ';' }))
{
this.CreateCodeForProperty(assemblyBuilder, declaration, (ProfileNameTypeStruct) properties[str]);
}
ns.Types.Add(declaration);
}
// If using the Xrm Client, OptionSets are converted to nullable Ints
private static bool IsNullableIntPropery(CodeMemberProperty property)
{
return property.Type.BaseType == "System.Nullable`1" &&
property.Type.TypeArguments != null &&
property.Type.TypeArguments.Count == 1 &&
property.Type.TypeArguments[0].BaseType == "System.Int32";
}
public void Process(CodeNamespace code, System.Xml.Schema.XmlSchema schema)
{
foreach (CodeTypeDeclaration type in code.Types)
{
if (type.IsClass || type.IsStruct)
{
// Copy the colletion to an array for safety. We will be
// changing this collection.
CodeTypeMember[] members = new CodeTypeMember[type.Members.Count];
type.Members.CopyTo(members, 0);
foreach (CodeTypeMember member in members)
{
// Process fields only.
if (member is CodeMemberField)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = member.Name;
prop.Attributes = member.Attributes;
prop.Type = ((CodeMemberField)member).Type;
// Copy attributes from field to the property.
prop.CustomAttributes.AddRange(member.CustomAttributes);
member.CustomAttributes.Clear();
// Copy comments from field to the property.
prop.Comments.AddRange(member.Comments);
member.Comments.Clear();
// Modify the field.
member.Attributes = MemberAttributes.Private;
Char[] letters = member.Name.ToCharArray();
letters[0] = Char.ToLower(letters[0]);
member.Name = String.Concat("_", new string(letters));
prop.HasGet = true;
prop.HasSet = true;
// Add get/set statements pointing to field. Generates:
// return this._fieldname;
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
member.Name)));
// Generates:
// this._fieldname = value;
prop.SetStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
member.Name),
new CodeArgumentReferenceExpression("value")));
// Finally add the property to the type
type.Members.Add(prop);
}
}
}
}
}
public CodeMemberProperty AddProperty(string name, CodeTypeReference propType)
{
var property = new CodeMemberProperty();
property.Attributes = (MemberAttributes)24578; //Public Final
property.HasGet = true;
property.HasSet = true;
property.Name = name;
property.Type = propType;
var memberName = char.ToLower(property.Name[0]) + property.Name.Substring(1);
memberName = memberName.Insert(0, "_");
var field = new CodeMemberField() {
Name = memberName,
Type = propType,
Attributes = MemberAttributes.Private
};
property.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberName)));
property.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberName), new CodePropertySetValueReferenceExpression()));
_base.Members.Add(field);
_base.Members.Add(property);
return property;
}
protected internal override object InsideCodeTypeDeclaration(CodeTypeDeclaration decl)
{
// if getter is omitted, just output the setter like a method
if (decl.IsInterface || Getter == null) {
if (Getter != null)
Getter.Visit (decl);
if (Setter != null)
Setter.Visit (decl);
return null;
} else if (!decl.IsClass)
return null;
var prop = new CodeMemberProperty {
Name = this.Name,
// FIXME: For now, no properties will be virtual... change this at some point?
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Type = Getter.ReturnTypeReference
};
Getter.Visit (prop.GetStatements);
if (Setter != null)
Setter.Visit (prop.SetStatements);
decl.Members.Add (prop);
return prop;
}
public void Visit(ProxyList statement)
{
var property = new CodeMemberProperty();
property.Attributes = MemberAttributes.Override | MemberAttributes.Family;
property.Name = "Proxies";
property.HasSet = false;
property.Type = new CodeTypeReference(typeof(string[]));
property.GetStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(string[])), "proxies",
new CodeArrayCreateExpression(new CodeTypeReference(typeof(string[])), new CodePrimitiveExpression(statement.Proxies.Length)))
);
for (int x = 0; x < statement.Proxies.Length; x++ )
{
if (!Proxy.TryParse(statement.Proxies[x].Value))
Errors.Add(new BadProxyFormat(new Semantic.LineInfo(statement.Proxies[x].Line.Line, statement.Proxies[x].Line.CharacterPosition)));
property.GetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("proxies"),
new CodePrimitiveExpression(x)), new CodePrimitiveExpression(statement.Proxies[x].Value))
);
}
property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("proxies")));
_mainType.Type.Members.Add(property);
}
public void DecorateProperty(CodeMemberProperty propertyDefinition, KeyValuePair<string, JsonSchema> propertyPair)
{
propertyDefinition.ThrowIfNull("propertyDefinition");
propertyPair.ThrowIfNull("propertyPair");
propertyDefinition.Comments.AddRange(CreateComment(propertyPair.Value));
}
public override void OnProcessGeneratedCode(ControlBuilder controlBuilder, CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod, System.Collections.IDictionary additionalState)
{
// only run this once during page compilation, and only use this one builder (so that we don't get master pages, etc.)
if (controlBuilder.GetType() == typeof(FileLevelPageControlBuilder))
{
// the page will only contain one namespace and one type
var ns = codeCompileUnit.Namespaces.Cast<CodeNamespace>().FirstOrDefault();
if (ns != null)
{
var type = ns.Types.Cast<CodeTypeDeclaration>().FirstOrDefault();
if (type != null)
{
/* When this is output, it will inject this into every page:
*
* protected override PageStatePersister PageStatePersister {
* get { return new CompressedHiddenFieldPageStatePersister(this); }
* }
*
*/
CodeMemberProperty property = new CodeMemberProperty()
{
Name = "PageStatePersister",
HasGet = true,
Attributes = MemberAttributes.Override | MemberAttributes.Family,
Type = new CodeTypeReference(typeof(PageStatePersister))
};
var newObj = new CodeObjectCreateExpression(typeof(CompressedHiddenFieldPageStatePersister), new CodeThisReferenceExpression());
property.GetStatements.Add(new CodeMethodReturnStatement(newObj));
type.Members.Add(property);
}
}
}
base.OnProcessGeneratedCode(controlBuilder, codeCompileUnit, baseType, derivedType, buildMethod, dataBindingMethod, additionalState);
}
private static void GenerateCSharpCode(Entity entity, string path)
{
var targetUnit = new CodeCompileUnit();
var targetNamespace = new CodeNamespace(entity.FullName.Substring(0, entity.FullName.LastIndexOf('.')));
targetNamespace.Imports.Add(new CodeNamespaceImport("System"));
var targetClass = new CodeTypeDeclaration(entity.FullName.Substring(entity.FullName.LastIndexOf('.') + 1))
{
IsClass = true,
IsPartial = true,
TypeAttributes = TypeAttributes.Public
};
targetNamespace.Types.Add(targetClass);
targetUnit.Namespaces.Add(targetNamespace);
foreach (var property in entity.Properties)
{
CodeTypeReference propertyType;
if (property.IsNavigable)
{
propertyType = new CodeTypeReference(typeof(List<>));
propertyType.TypeArguments.Add((string)RemapTypeForCSharp(property.Type));
}
else
{
propertyType = new CodeTypeReference(RemapTypeForCSharp(property.Type));
}
var backingField = new CodeMemberField(propertyType, "_" + property.Name) {Attributes = MemberAttributes.Private};
if (property.IsNavigable)
backingField.InitExpression = new CodeObjectCreateExpression(propertyType);
targetClass.Members.Add(backingField);
var codeProperty = new CodeMemberProperty
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = property.Name,
HasGet = true,
HasSet = true,
Type = propertyType,
};
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name)));
codeProperty.SetStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name),
new CodeVariableReferenceExpression("value")));
targetClass.Members.Add(codeProperty);
}
var provider = CodeDomProvider.CreateProvider("CSharp");
var options = new CodeGeneratorOptions {BracingStyle = "C"};
using (var writer = new StreamWriter(Path.Combine(path, entity.FullName + '.' + provider.FileExtension)))
{
provider.GenerateCodeFromCompileUnit(targetUnit, writer, options);
}
}
private bool SkipProperty(CodeMemberProperty property, CodeTypeDeclaration type)
{
List<string> attributes;
return property == null ||
!IsOptionSetProperty(property) ||
(UnmappedProperties.TryGetValue(type.Name.ToLower(), out attributes) && attributes.Contains(property.Name.ToLower())) ||
property.CustomAttributes.Cast<CodeAttributeDeclaration>().Any(att => att.Name == "System.ObsoleteAttribute");
}
public CodeDefaultProperty(CodeMemberProperty property,
CodeParameterDeclarationExpressionCollection parameters,
bool isDefault)
{
Parameters = parameters;
IsDefault = isDefault;
_property = property;
}
public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = name;
prop.Type = new CodeTypeReference(typeof(bool));
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.GetStatements.Add(new CodeSnippetStatement("\t\t\t\t" + code));
ctd.Members.Add(prop);
}
public static CodeTypeDeclaration GetEntityForTableDescription(DbSyncTableDescription tableDesc, bool addKeyAttributes, Dictionary<string, string> colsMapping)
{
CodeTypeDeclaration entityDeclaration = new CodeTypeDeclaration(SanitizeName(tableDesc.UnquotedGlobalName));
entityDeclaration.IsPartial = true;
entityDeclaration.IsClass = true;
foreach (DbSyncColumnDescription column in tableDesc.Columns)
{
string colName = column.UnquotedName;
if (colsMapping != null)
{
colsMapping.TryGetValue(column.UnquotedName.ToLowerInvariant(), out colName);
colName = colName ?? column.UnquotedName;
}
CodeTypeReference fieldTypeReference = GetTypeFromSqlType(tableDesc, column);
CodeMemberField colField = new CodeMemberField(fieldTypeReference, "_" + SanitizeName(colName));
colField.Attributes = MemberAttributes.Private;
CodeMemberProperty propertyField = new CodeMemberProperty();
propertyField.Attributes = MemberAttributes.Public | MemberAttributes.Final;
propertyField.Name = SanitizeName(colName);
propertyField.Type = fieldTypeReference;
propertyField.GetStatements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression(colField.Name)));
propertyField.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(colField.Name), new CodeVariableReferenceExpression("value")));
if (addKeyAttributes)
{
if (column.IsPrimaryKey)
{
//Add the Key attribute
propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.ClientKeyAtributeType));
}
}
else
{
// This is service entity. Check to see if column mappings is present i.e colName is not the same as column.UnquotedName.
if (!colName.Equals(column.UnquotedName, StringComparison.Ordinal))
{
propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.ServiceSyncColumnMappingAttribute,
new CodeAttributeArgument("LocalName", new CodeSnippetExpression("\"" + column.UnquotedName + "\""))));
}
// For a nullable data type, we add the [SyncEntityPropertyNullable] attribute to the property that is code-generated.
// This is required because some data types such as string are nullable by default in .NET and so there is no good way to
// later determine whether the type in the underlying data store is nullable or not.
if (column.IsNullable)
{
propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.EntityPropertyNullableAttributeType));
}
}
entityDeclaration.Members.Add(colField);
entityDeclaration.Members.Add(propertyField);
}
return entityDeclaration;
}
private void AddMemberOverride(string name, Type type, CodeExpression expr) {
CodeMemberProperty member = new CodeMemberProperty();
member.Name = name;
member.Attributes = MemberAttributes.Override | MemberAttributes.Family;
member.Type = new CodeTypeReference(type.FullName);
CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(expr);
member.GetStatements.Add(returnStmt);
_sourceDataClass.Members.Add(member);
}
public CodeMemberProperty ToProperty()
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = this.Member;
//var provider = new Microsoft.CSharp.CSharpCodeProvider();
return null;
}
private object GetReturnPrimitiveValue(CodeMemberProperty property)
{
Assert.That(property.GetStatements.Count, Is.EqualTo(1));
Assert.That(property.GetStatements[0], Is.TypeOf(typeof(CodeMethodReturnStatement)));
var returnStatement = property.GetStatements[0] as CodeMethodReturnStatement;
Assert.That(returnStatement.Expression, Is.TypeOf(typeof(CodePrimitiveExpression)));
var primitive = returnStatement.Expression as CodePrimitiveExpression;
return primitive.Value;
}
private CodeCompileUnit GeneraCodigo()
{
//Unidad de Compilación (ensamblado)
var cu = new CodeCompileUnit();
cu.ReferencedAssemblies.Add("System.dll");//Ensamblados que enlaza (aunque este debería estar por defecto)
//Espacio de nombres
var n = new CodeNamespace("EjemploGeneracionCodigo1");
cu.Namespaces.Add(n);
n.Imports.Add(new CodeNamespaceImport("System"));//Espacios de nombres que utiliza este namespace para compilar
//Clase
var c = new CodeTypeDeclaration("ClaseGenerada");
n.Types.Add(c);
c.BaseTypes.Add(new CodeTypeReference(typeof(System.Timers.Timer)));//Su clase padre
c.IsPartial = true;
//Atributo de la clase
CodeMemberField mf = new CodeMemberField(typeof(string),"_atributo");
c.Members.Add(mf);
//Propiedad de la clase
CodeMemberProperty cp = new CodeMemberProperty();
c.Members.Add(cp);
cp.Attributes = MemberAttributes.Public | MemberAttributes.Final;//lo de Final para que no sea virtual (por defecto si es público es virtual)
cp.Type = new CodeTypeReference(typeof(string));
cp.Name = "atributo";
CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_atributo");
CodeMethodReturnStatement mrs = new CodeMethodReturnStatement(cfre);
cp.GetStatements.Add(mrs);
//Metodo de la clase
CodeMemberMethod cmm = new CodeMemberMethod();
c.Members.Add(cmm);
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Name = "Metodo1";
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression pde = new CodeParameterDeclarationExpression(typeof(int),"enteroDeEntrada");
cmm.Parameters.Add(pde);
pde = new CodeParameterDeclarationExpression(typeof(string),"cadenaDeEntrada");
cmm.Parameters.Add(pde);
//Declaración de variable
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(string),"aux",new CodePrimitiveExpression("Prueba1") );
cmm.Statements.Add(vds);
//Llamar a método arbitrario
//variable a llamar y método
CodeMethodReferenceExpression ctr = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression("Console"),"WriteLine");
//Llamada en sí con sus parámetros
CodeMethodInvokeExpression invoke1 = new CodeMethodInvokeExpression( ctr, new CodeExpression[] {new CodePrimitiveExpression("Hola mundo")} );
cmm.Statements.Add(invoke1);
//Código a pelo. Ojo no se puede generar, por ejemplo, un foreach.
cmm.Statements.Add(new CodeSnippetStatement("foreach(string s in cadenas){"));
cmm.Statements.Add(new CodeSnippetStatement("Console.WriteLine(s);"));
cmm.Statements.Add(new CodeSnippetStatement("}"));
mrs = new CodeMethodReturnStatement(new CodePrimitiveExpression(42));
cmm.Statements.Add(mrs);
return cu;
}
public override void GenerateCode(AssemblyBuilder myAb)
{
XmlDocument carXmlDoc = new XmlDocument();
using (Stream passedFile = OpenStream())
{
carXmlDoc.Load(passedFile);
}
XmlNode mainNode = carXmlDoc.SelectSingleNode("/car");
string selectionMainNode = mainNode.Attributes["name"].Value;
XmlNode colorNode = carXmlDoc.SelectSingleNode("/car/color");
string selectionColorNode = colorNode.InnerText;
XmlNode doorNode = carXmlDoc.SelectSingleNode("/car/door");
string selectionDoorNode = doorNode.InnerText;
XmlNode speedNode = carXmlDoc.SelectSingleNode("/car/speed");
string selectionSpeedNode = speedNode.InnerText;
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cn = new CodeNamespace();
CodeMemberProperty cmp1 = new CodeMemberProperty();
CodeMemberProperty cmp2 = new CodeMemberProperty();
CodeMemberMethod cmm1 = new CodeMemberMethod();
cn.Imports.Add(new CodeNamespaceImport("System"));
cmp1.Name = "Color";
cmp1.Type = new CodeTypeReference(typeof(string));
cmp1.Attributes = MemberAttributes.Public;
cmp1.GetStatements.Add(new CodeSnippetExpression("return \"" +
selectionColorNode + "\""));
cmp2.Name = "Doors";
cmp2.Type = new CodeTypeReference(typeof(int));
cmp2.Attributes = MemberAttributes.Public;
cmp2.GetStatements.Add(new CodeSnippetExpression("return " +
selectionDoorNode));
cmm1.Name = "Go";
cmm1.ReturnType = new CodeTypeReference(typeof(int));
cmm1.Attributes = MemberAttributes.Public;
cmm1.Statements.Add(new CodeSnippetExpression("return " +
selectionSpeedNode));
CodeTypeDeclaration ctd = new CodeTypeDeclaration(selectionMainNode);
ctd.Members.Add(cmp1);
ctd.Members.Add(cmp2);
ctd.Members.Add(cmm1);
cn.Types.Add(ctd);
ccu.Namespaces.Add(cn);
myAb.AddCodeCompileUnit(this, ccu);
}
protected void SetImplementationTypes(CodeMemberProperty member)
{
if (this.privateImplementationType!=null)
member.PrivateImplementationType = this.privateImplementationType.TypeReference;
foreach(ITypeDeclaration td in this.implementationTypes)
{
member.ImplementationTypes.Add(td.TypeReference);
}
}
/// <summary>
/// Creates the data member attribute.
/// </summary>
/// <param name="prop">Represents a declaration for a property of a type.</param>
protected override void CreateDataMemberAttribute(CodeMemberProperty prop)
{
base.CreateDataMemberAttribute(prop);
if (GeneratorContext.GeneratorParams.GenerateDataContracts)
{
var attrib = new CodeTypeReference("System.Runtime.Serialization.DataMemberAttribute");
prop.CustomAttributes.Add(new CodeAttributeDeclaration(attrib));
}
}
protected void SetType(CodeMemberProperty propNode, GenericProperty property)
{
var hasType = property.Type != null &&
Config.TypeMappings.ContainsKey(property.Type.ToLower());
var typeName = hasType
? Config.TypeMappings[property.Type.ToLower()]
: Config.TypeMappings.DefaultType;
if (typeName == null)
throw new Exception("TypeMappings/Default not set. Cannot guess default property type.");
propNode.Type = new CodeTypeReference(typeName);
}
private void AddMemberOverride(string name, Type type, CodeExpression expr)
{
CodeMemberProperty property = new CodeMemberProperty {
Name = name,
Attributes = MemberAttributes.Family | MemberAttributes.Override,
Type = new CodeTypeReference(type.FullName)
};
CodeMethodReturnStatement statement = new CodeMethodReturnStatement(expr);
property.GetStatements.Add(statement);
base._sourceDataClass.Members.Add(property);
}
// Generate a codedom property expression and attach it to the codedom type.
public static void Emit(CodeTypeDeclaration codeTypeDeclaration, Property property)
{
// Create the codedom property and attach it to the codedom type.
var codeProperty = new CodeMemberProperty();
codeTypeDeclaration.Members.Add(codeProperty);
// Assign the name.
codeProperty.Name = property.Name;
// Assign the return type, making sure to check for null.
if (property.TypeName == "void")
codeProperty.Type = null;
else
codeProperty.Type = new CodeTypeReference(property.TypeName);
// Translate the accessibility.
MemberAttributes memberAttributes = MemberAttributes.Public;
switch (property.Accessibility)
{
case Accessibility.Internal:
memberAttributes = MemberAttributes.FamilyAndAssembly;
break;
case Accessibility.Private:
memberAttributes = MemberAttributes.Private;
break;
case Accessibility.Protected:
memberAttributes = MemberAttributes.Family;
break;
case Accessibility.Public:
memberAttributes = MemberAttributes.Public;
break;
}
// Shared = static
if (property.IsShared) memberAttributes |= MemberAttributes.Static;
if (property.IsAbstract) memberAttributes |= MemberAttributes.Abstract;
if (property.IsOverride) memberAttributes |= MemberAttributes.Override;
codeProperty.Attributes = memberAttributes;
// Add the statements for the get block.
if (property.GetBlock.ChildExpressions.Count > 0)
foreach (var e in property.GetBlock.ChildExpressions)
codeProperty.GetStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
else
codeProperty.GetStatements.Add(new CodeCommentStatement("Placeholder statement"));
// Add the statements for the set block.
if (property.SetBlock.ChildExpressions.Count > 0)
foreach (var e in property.SetBlock.ChildExpressions)
codeProperty.SetStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
else
codeProperty.SetStatements.Add(new CodeCommentStatement("Placeholder statement"));
}
/// <summary>
/// Handles if Ignore keyword is specified in AppInfo tag
/// </summary>
/// <param name="memberProperty">Member of particualr class in which AppInfo is available</param>
/// <param name="appInfoValue">value of AppInfo tag</param>
public void HandleAppInfo(System.CodeDom.CodeMemberProperty memberProperty, string appInfoValue)
{
if (string.Equals(appInfoValue.Trim(), "IGNORE", System.StringComparison.OrdinalIgnoreCase))
{
// Add [XmlIgnore] attribute
memberProperty.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(System.Xml.Serialization.XmlIgnoreAttribute))));
// Add [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] attribute
CodeDomHelper.AddEditorBrowsableAttribute(memberProperty);
}
}
public static System.CodeDom.CodeCompileUnit BuildGraph(System.Xml.XmlDocument xmlMetaData,
string tableName)
{
System.Xml.XmlNodeList nodeList;
System.CodeDom.CodeCompileUnit compileUnit = new System.CodeDom.CodeCompileUnit();
System.CodeDom.CodeNamespace nSpace;
System.CodeDom.CodeTypeDeclaration clsTable;
nodeList = xmlMetaData.SelectNodes("/DataSet/Table[@Name='" + tableName + "']/Column");
nSpace = new System.CodeDom.CodeNamespace("ClassViaCodeDOM");
compileUnit.Namespaces.Add(nSpace);
nSpace.Imports.Add(new System.CodeDom.CodeNamespaceImport("System"));
clsTable = new System.CodeDom.CodeTypeDeclaration(tableName);
nSpace.Types.Add(clsTable);
System.CodeDom.CodeMemberField field;
foreach (System.Xml.XmlNode node in nodeList)
{
field = new System.CodeDom.CodeMemberField();
field.Name = "m_" + node.Attributes["Name"].Value;
field.Attributes = System.CodeDom.MemberAttributes.Private;
field.Type = new System.CodeDom.CodeTypeReference(node.Attributes["Type"].Value);
clsTable.Members.Add(field);
}
System.CodeDom.CodeMemberProperty prop;
string name;
foreach (System.Xml.XmlNode node in nodeList)
{
prop = new System.CodeDom.CodeMemberProperty();
name = node.Attributes["Name"].Value;
prop.Name = name;
prop.Attributes = System.CodeDom.MemberAttributes.Public;
prop.Type = new System.CodeDom.CodeTypeReference(node.Attributes["Type"].Value);
prop.GetStatements.Add(new System.CodeDom.CodeMethodReturnStatement(new System.CodeDom.CodeFieldReferenceExpression(new System.CodeDom.CodeThisReferenceExpression(), "m_" + name)));
prop.SetStatements.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeFieldReferenceExpression(new System.CodeDom.CodeThisReferenceExpression(), "m_" + name), new System.CodeDom.CodePropertySetValueReferenceExpression()));
clsTable.Members.Add(prop);
}
return(compileUnit);
}
internal DesignTimePropertyInfo(DesignTimeType declaringType, System.CodeDom.CodeMemberProperty property)
{
this.property = property;
this.declaringType = declaringType;
}
protected override void GenerateProperty(System.CodeDom.CodeMemberProperty e, System.CodeDom.CodeTypeDeclaration c)
{
throw new Exception("The method or operation is not implemented.");
}
