public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit,
CodeNamespace generatedNamespace,
CodeTypeDeclaration generatedClass,
CodeMemberMethod executeMethod)
{
base.ProcessGeneratedCode(codeCompileUnit, generatedNamespace, generatedClass, executeMethod);
// Create the Href wrapper
CodeTypeMember hrefMethod = new CodeSnippetTypeMember(@"
// Resolve package relative syntax
// Also, if it comes from a static embedded resource, change the path accordingly
public override string Href(string virtualPath, params object[] pathParts) {
virtualPath = ApplicationPart.ProcessVirtualPath(GetType().Assembly, VirtualPath, virtualPath);
return base.Href(virtualPath, pathParts);
}");
generatedClass.Members.Add(hrefMethod);
Debug.Assert(generatedClass.Name.Length > 0);
if (!(Char.IsLetter(generatedClass.Name[0]) || generatedClass.Name[0] == '_'))
{
generatedClass.Name = '_' + generatedClass.Name;
}
// If the generatedClass starts with an underscore, add a ClsCompliant(false) attribute.
if (generatedClass.Name[0] == '_')
{
generatedClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(CLSCompliantAttribute).FullName,
new CodeAttributeArgument(new CodePrimitiveExpression(false))));
}
}
public CodeCompileUnit GenerateCode(string typeName, string codeBody,
StringCollection imports,
string prefix)
{
var compileUnit = new CodeCompileUnit();
var typeDecl = new CodeTypeDeclaration(typeName);
typeDecl.IsClass = true;
typeDecl.TypeAttributes = TypeAttributes.Public;
// create constructor
var constructMember = new CodeConstructor {Attributes = MemberAttributes.Public};
typeDecl.Members.Add(constructMember);
// pump in the user specified code as a snippet
var literalMember =
new CodeSnippetTypeMember(codeBody);
typeDecl.Members.Add(literalMember);
var nspace = new CodeNamespace();
////Add default imports
//foreach (string nameSpace in ScriptExecuter._namespaces)
//{
// nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
//}
foreach (string nameSpace in imports)
{
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
compileUnit.Namespaces.Add(nspace);
nspace.Types.Add(typeDecl);
return compileUnit;
}
//construct, given the code provider being used.
public CompileDirectives(CodeDomProvider codeProvider)
{
this.codeProvider = codeProvider;
if (codeProvider.FileExtension == "cs")
{
readonlySnip = new CodeSnippetTypeMember("readonly ");
isCSharp = true;
}
if (codeProvider.FileExtension == "vb")
readonlySnip = new CodeSnippetTypeMember("ReadOnly ");
//try and load the directives from the user config.
try
{
//GenericType
string defaultDiretive = Properties.Settings.Default.DefaultCompilerDirectives.Trim();
if (defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Length == 3)
directives = defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
System.Reflection.PropertyInfo[] properties = Properties.Settings.Default.GetType().GetProperties();
foreach (System.Reflection.PropertyInfo property in properties)
{
if (property.PropertyType == typeof(string) && property.Name.EndsWith("CompilerDirectives", StringComparison.InvariantCultureIgnoreCase))
{
string directive = property.GetValue(Properties.Settings.Default, null) as string;
if (directive != null)
{
string[] lines = directive.Trim().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length == 4)
{
if (("*." + codeProvider.FileExtension).Equals(lines[0].Trim(), StringComparison.InvariantCultureIgnoreCase))
{
for (int i = 0; i < 3; i++)
{
directives[i] = lines[i + 1];
}
}
}
}
}
}
for (int i = 0; i < directives.Length; i++)
{
directives[i] = directives[i].Trim();
}
if (directives[0].Contains("{0}") == false)
throw new Exception("Could not find {0} in directive 0");
}
catch (Exception e)
{
throw new Exception("Error in user.config file", e);
}
}
public TypescriptSnippetTypeMember(
CodeSnippetTypeMember member,
CodeGeneratorOptions options)
{
_member = member;
_options = options;
}
/// <summary>
/// Generates the partial method for an action.
/// </summary>
/// <param name = "message">The message.</param>
/// <param name = "argumentType">Type of the argument.</param>
/// <returns>The type member.</returns>
protected override CodeTypeMember GenerateActionPartialMethod(string message, IType argumentType)
{
String selector = message;
String name = GenerateMethodName (selector);
// Partial method are only possible by using a snippet of code as CodeDom does not handle them
CodeSnippetTypeMember method = new CodeSnippetTypeMember ("partial void " + name + "(" + argumentType.Name + " sender);" + Environment.NewLine);
return method;
}
/// <summary>
/// Generates the partial method for an action.
/// </summary>
/// <param name = "message">The message.</param>
/// <param name = "argumentType">Type of the argument.</param>
/// <returns>The type member.</returns>
protected override CodeTypeMember GenerateActionPartialMethod(string message, IType argumentType)
{
String selector = message;
String name = GenerateMethodName (selector);
// Partial method are only possible by using a snippet of code as CodeDom does not handle them
String content = String.Format ("Partial Private Sub {0}({1} sender){2}End Sub{2}", name, argumentType.Name, Environment.NewLine);
CodeSnippetTypeMember method = new CodeSnippetTypeMember (content);
return method;
}
public void AddScriptBlock(string source, string uriString, int lineNumber, Location end) {
CodeSnippetTypeMember scriptSnippet = new CodeSnippetTypeMember(source);
string fileName = SourceLineInfo.GetFileName(uriString);
if (lineNumber > 0) {
scriptSnippet.LinePragma = new CodeLinePragma(fileName, lineNumber);
scriptUris[fileName] = uriString;
}
typeDecl.Members.Add(scriptSnippet);
this.endUri = uriString;
this.endLoc = end;
}
public static CodeTypeMember CreatePropertyCode(this SAPDataParameter p)
{
CodeSnippetTypeMember snippet = new CodeSnippetTypeMember();
if (p.Comment != null)
{
snippet.Comments.Add(new CodeCommentStatement(p.Comment, true));
}
snippet.Text = string.Format("public {0} {1} {{get;set;}}", p.Type.ToString(), p.Name);
return snippet;
}
public void AddScriptBlock(string source, string uriString, int lineNumber, int endLine, int endPos) {
CodeSnippetTypeMember scriptSnippet = new CodeSnippetTypeMember(source);
string fileName = SourceLineInfo.GetFileName(uriString);
if (lineNumber > 0) {
scriptSnippet.LinePragma = new CodeLinePragma(fileName, lineNumber);
scriptFiles.Add(fileName);
}
typeDecl.Members.Add(scriptSnippet);
this.endFileName = fileName;
this.endLine = endLine;
this.endPos = endPos;
}
private static CodeTypeDeclaration CraeteCodeInterfaceDeclaration(XpidlInterface xpidlInterface, out CodeTypeDeclaration codeConstClassDeclaration)
{
// Create interface declaration
var codeInterfaceDeclaration =
new CodeTypeDeclaration(xpidlInterface.Name)
{
IsInterface = true,
TypeAttributes = TypeAttributes.Interface | TypeAttributes.NotPublic
};
// Set base interface (except of nsISupports)
if (!String.IsNullOrEmpty(xpidlInterface.BaseName) && !String.Equals(xpidlInterface.BaseName, XpidlType.nsISupports))
{
codeInterfaceDeclaration.BaseTypes.Add(xpidlInterface.BaseName);
var baseInterfaceMembers = new CodeSnippetTypeMember();
baseInterfaceMembers.Comments.Add(
new CodeCommentStatement(new CodeComment(String.Format("TODO: declare {0} members here", xpidlInterface.BaseName), false)));
baseInterfaceMembers.StartDirectives.Add(
new CodeRegionDirective(CodeRegionMode.Start, String.Format("{0} Members", xpidlInterface.BaseName)));
baseInterfaceMembers.EndDirectives.Add(
new CodeRegionDirective(CodeRegionMode.End, null));
codeInterfaceDeclaration.Members.Add(baseInterfaceMembers);
}
// Add [ComImport] attribute
var comImportAttributeDeclaration =
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(ComImportAttribute)));
codeInterfaceDeclaration.CustomAttributes.Add(comImportAttributeDeclaration);
// Add [Guid] attribute
var guidAttributeDeclaration =
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(GuidAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(xpidlInterface.Uuid.ToString())));
codeInterfaceDeclaration.CustomAttributes.Add(guidAttributeDeclaration);
// Add [InterfaceType] attribute
var interfaceTypeAttributeDeclaration =
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(InterfaceTypeAttribute)),
new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(ComInterfaceType)), ComInterfaceType.InterfaceIsIUnknown.ToString())));
codeInterfaceDeclaration.CustomAttributes.Add(interfaceTypeAttributeDeclaration);
// Create interface members and get separate class for interface constants
codeConstClassDeclaration = BuildCodeInterfaceDeclaration(codeInterfaceDeclaration, xpidlInterface);
return codeInterfaceDeclaration;
}
internal ObjectFactoryCodeDomTreeGenerator(string outputAssemblyName)
{
CodeConstructor constructor;
this._codeCompileUnit = new System.CodeDom.CodeCompileUnit();
CodeNamespace namespace2 = new CodeNamespace("__ASP");
this._codeCompileUnit.Namespaces.Add(namespace2);
string name = "FastObjectFactory_" + Util.MakeValidTypeNameFromString(outputAssemblyName).ToLower(CultureInfo.InvariantCulture);
this._factoryClass = new CodeTypeDeclaration(name);
this._factoryClass.TypeAttributes &= ~TypeAttributes.Public;
CodeSnippetTypeMember member = new CodeSnippetTypeMember(string.Empty) {
LinePragma = new CodeLinePragma(@"c:\\dummy.txt", 1)
};
this._factoryClass.Members.Add(member);
constructor = new CodeConstructor {
Attributes = constructor.Attributes | MemberAttributes.Private
};
this._factoryClass.Members.Add(constructor);
namespace2.Types.Add(this._factoryClass);
}
public void Constructor0 ()
{
CodeSnippetTypeMember cstm = new CodeSnippetTypeMember ();
Assert.AreEqual (MemberAttributes.Private | MemberAttributes.Final,
cstm.Attributes, "#1");
Assert.IsNotNull (cstm.Comments, "#2");
Assert.AreEqual (0, cstm.Comments.Count, "#3");
Assert.IsNotNull (cstm.CustomAttributes, "#4");
Assert.AreEqual (0, cstm.CustomAttributes.Count, "#5");
#if NET_2_0
Assert.IsNotNull (cstm.StartDirectives, "#6");
Assert.AreEqual (0, cstm.StartDirectives.Count, "#7");
Assert.IsNotNull (cstm.EndDirectives, "#8");
Assert.AreEqual (0, cstm.EndDirectives.Count, "#9");
#endif
Assert.IsNotNull (cstm.Text, "#10");
Assert.AreEqual (string.Empty, cstm.Text, "#11");
Assert.IsNull (cstm.LinePragma, "#12");
Assert.IsNotNull (cstm.Name, "#13");
Assert.AreEqual (string.Empty, cstm.Name, "#14");
Assert.IsNotNull (cstm.UserData, "#15");
Assert.AreEqual (typeof(ListDictionary), cstm.UserData.GetType (), "#16");
Assert.AreEqual (0, cstm.UserData.Count, "#17");
cstm.Name = null;
Assert.IsNotNull (cstm.Name, "#18");
Assert.AreEqual (string.Empty, cstm.Name, "#19");
CodeLinePragma clp = new CodeLinePragma ("mono", 10);
cstm.LinePragma = clp;
Assert.IsNotNull (cstm.LinePragma, "#20");
Assert.AreSame (clp, cstm.LinePragma, "#21");
}
internal ObjectFactoryCodeDomTreeGenerator(string outputAssemblyName) {
_codeCompileUnit = new CodeCompileUnit();
CodeNamespace sourceDataNamespace = new CodeNamespace(
BaseCodeDomTreeGenerator.internalAspNamespace);
_codeCompileUnit.Namespaces.Add(sourceDataNamespace);
// Make the class name vary based on the assembly (VSWhidbey 363214)
string factoryClassName = factoryClassNameBase +
Util.MakeValidTypeNameFromString(outputAssemblyName).ToLower(CultureInfo.InvariantCulture);
// Create a single class, in which a method will be added for each
// type that needs to be fast created in this assembly
_factoryClass = new CodeTypeDeclaration(factoryClassName);
// Make the class internal (VSWhidbey 363214)
_factoryClass.TypeAttributes &= ~TypeAttributes.Public;
// We generate a dummy line pragma, just so it will end with a '#line hidden'
// and prevent the following generated code from ever being treated as user
// code. We need to use this hack because CodeDOM doesn't allow simply generating
// a '#line hidden'. (VSWhidbey 199384)
CodeSnippetTypeMember dummySnippet = new CodeSnippetTypeMember(String.Empty);
#if !PLATFORM_UNIX /// Unix file system
// CORIOLISTODO: Unix file system
dummySnippet.LinePragma = new CodeLinePragma(@"c:\\dummy.txt", 1);
#else // !PLATFORM_UNIX
dummySnippet.LinePragma = new CodeLinePragma(@"/dummy.txt", 1);
#endif // !PLATFORM_UNIX
_factoryClass.Members.Add(dummySnippet);
// Add a private default ctor to make the class non-instantiatable (VSWhidbey 340829)
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes |= MemberAttributes.Private;
_factoryClass.Members.Add(ctor);
sourceDataNamespace.Types.Add(_factoryClass);
}
internal string GenerateSimpleType(
XmlSchemaSimpleType type,
CodeCompileUnit compileUnit,
CodeNamespace mainNamespace,
CodeGenerationOptions options,
CodeDomProvider codeProvider)
{
CodeTypeDeclaration codeClass = CodeDomHelper.CreateClassDeclaration(type);
mainNamespace.Types.Add(codeClass);
CodeDomHelper.GenerateXmlTypeAttribute(codeClass, type.QualifiedName.Name, type.QualifiedName.Namespace);
XmlSchemaSimpleTypeRestriction restriction = type.Content as XmlSchemaSimpleTypeRestriction;
Type baseType = XsdToClrPrimitive(restriction.BaseTypeName);
CodeMemberField field = CodeDomHelper.AddField(codeClass, "value", baseType);
CodeMemberProperty prop = CodeDomHelper.AddPropertyDeclaration(codeClass, field, "Value", baseType);
CodeDomHelper.AddTextAttribute(prop.CustomAttributes);
CodeDomHelper.AddCtor(codeClass);
CodeDomHelper.AddCtor(codeClass, prop);
// for each facet we support, add validation to the setter
foreach (object facet in restriction.Facets)
{
XmlSchemaLengthFacet length = facet as XmlSchemaLengthFacet;
if (length != null)
{
int? value = ToInt32(length.Value);
if (value.HasValue)
{
CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length");
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(value));
prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("length", value) }, new CodeStatement[0]));
}
continue;
}
XmlSchemaPatternFacet pattern = facet as XmlSchemaPatternFacet;
if (pattern != null)
{
// TODO: might want ot validate the pattern value here to make sure that it is a valid Regex.
if (!string.IsNullOrEmpty(pattern.Value))
{
CodeExpression patternMatch =
CodeDomHelper.MethodCall(
CodeDomHelper.TypeExpr(typeof(Regex)), "IsMatch", new CodeExpression[] { CodeDomHelper.Value(), CodeDomHelper.Primitive(pattern.Value) });
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(patternMatch, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(true));
prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("pattern", pattern.Value) }, new CodeStatement[0]));
}
continue;
}
XmlSchemaMinLengthFacet minLength = facet as XmlSchemaMinLengthFacet;
if (minLength != null)
{
int? value = ToInt32(minLength.Value);
if (value.HasValue)
{
CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length");
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(value));
prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("minLength", value) }, new CodeStatement[0]));
}
continue;
}
XmlSchemaMaxLengthFacet maxLength = facet as XmlSchemaMaxLengthFacet;
if (maxLength != null)
{
int? value = ToInt32(maxLength.Value);
if (value.HasValue)
{
CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length");
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.GreaterThan, new CodePrimitiveExpression(value));
prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("maxLength", value) }, new CodeStatement[0]));
}
continue;
}
}
//add ToSrting() Overload and implicit and explicit Cast operators for compatibilty woth previously generated code
CodeMemberMethod toString = CodeDomHelper.MethodDecl(typeof(string), "ToString", MemberAttributes.Public | MemberAttributes.Override);
toString.Statements.Add(CodeDomHelper.Return(CodeDomHelper.Property("value")));
codeClass.Members.Add(toString);
// Unfortunately CodeDom does not support operators, so we have to use CodeSnippet to generate the Cast operators
// CodeSnippet is not language aware, so we have to use different snippets for different providers
// this version only support c# syntax
if (codeProvider is Microsoft.CSharp.CSharpCodeProvider)
{
string implicitCast = string.Format(" public static implicit operator {0}({1} x) {{ return new {0}(x); }}", codeClass.Name, baseType.FullName);
CodeSnippetTypeMember implicitOp = new CodeSnippetTypeMember(implicitCast);
codeClass.Members.Add(implicitOp);
string explicitCast = string.Format(" public static explicit operator {1}({0} x) {{ return x.Value; }}", codeClass.Name, baseType.FullName);
CodeSnippetTypeMember explicitOp = new CodeSnippetTypeMember(explicitCast);
codeClass.Members.Add(explicitOp);
}
return codeClass.Name;
}
/// <summary>
/// Generate Cast method in CodeDom and add it in reference class
/// </summary>
/// <param name="si">The service interface this grain reference type is being generated for</param>
/// <param name="isFactory">whether the class being generated is a factory class rather than a grainref implementation</param>
/// <param name="referenceClass">The class being generated for this grain reference type</param>
protected override void AddCastMethods(GrainInterfaceData si, bool isFactory, CodeTypeDeclaration referenceClass)
{
string castImplCode;
string checkCode = null;
if (isFactory)
{
castImplCode = string.Format(@"{0}.Cast(grainRef)", si.ReferenceClassName);
if (si.IsSystemTarget)
checkCode = @"if(!((global::Orleans.Runtime.GrainReference)grainRef).IsInitializedSystemTarget)
throw new InvalidOperationException(""InvalidCastException cast of a system target grain reference. Must have SystemTargetSilo set to the target silo address"");";
}
else
{
castImplCode = string.Format(
@"({0}) global::Orleans.Runtime.GrainReference.CastInternal(typeof({0}), (global::Orleans.Runtime.GrainReference gr) => {{ return new {1}(gr);}}, grainRef, {2})",
si.InterfaceTypeName, // Interface type for references for this grain
si.ReferenceClassName, // Concrete class for references for this grain
GrainInterfaceData.GetGrainInterfaceId(si.Type));
}
var methodImpl = string.Format(@"
{3} static {0} Cast(global::Orleans.Runtime.IAddressable grainRef)
{{
{1}
return {2};
}}", si.InterfaceTypeName, checkCode, castImplCode, "public");
var castMethod = new CodeSnippetTypeMember(methodImpl);
referenceClass.Members.Add(castMethod);
}
protected override void AddCreateObjectReferenceMethods(GrainInterfaceData grainInterfaceData, CodeTypeDeclaration factoryClass)
{
var fieldImpl = @"
private static global::Orleans.CodeGeneration.IGrainMethodInvoker methodInvoker;";
var invokerField = new CodeSnippetTypeMember(fieldImpl);
factoryClass.Members.Add(invokerField);
var methodImpl = String.Format(@"
public async static System.Threading.Tasks.Task<{0}> CreateObjectReference({0} obj)
{{
if (methodInvoker == null) methodInvoker = new {2}();
return {1}.Cast(await global::Orleans.Runtime.GrainReference.CreateObjectReference(obj, methodInvoker));
}}", grainInterfaceData.TypeName, grainInterfaceData.FactoryClassName, grainInterfaceData.InvokerClassName);
var createObjectReferenceMethod = new CodeSnippetTypeMember(methodImpl);
factoryClass.Members.Add(createObjectReferenceMethod);
methodImpl = String.Format(@"
public static System.Threading.Tasks.Task DeleteObjectReference({0} reference)
{{
return global::Orleans.Runtime.GrainReference.DeleteObjectReference(reference);
}}",
grainInterfaceData.TypeName);
var deleteObjectReferenceMethod = new CodeSnippetTypeMember(methodImpl);
factoryClass.Members.Add(deleteObjectReferenceMethod);
}
public CodeCompileUnit GenerateCode(string typeName, string codeBody,
StringCollection imports,
string prefix)
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(typeName);
typeDecl.IsClass = true;
typeDecl.TypeAttributes = TypeAttributes.Public;
// create constructor
CodeConstructor constructMember = new CodeConstructor();
constructMember.Attributes = MemberAttributes.Public;
constructMember.Parameters.Add(new CodeParameterDeclarationExpression("NAnt.Core.Project", "project"));
constructMember.Parameters.Add(new CodeParameterDeclarationExpression("NAnt.Core.PropertyDictionary", "propDict"));
constructMember.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("project"));
constructMember.BaseConstructorArgs.Add(new CodeVariableReferenceExpression ("propDict"));
typeDecl.Members.Add(constructMember);
typeDecl.BaseTypes.Add(typeof(FunctionSetBase));
// add FunctionSet attribute
CodeAttributeDeclaration attrDecl = new CodeAttributeDeclaration("FunctionSet");
attrDecl.Arguments.Add(new CodeAttributeArgument(
new CodeVariableReferenceExpression("\"" + prefix + "\"")));
attrDecl.Arguments.Add(new CodeAttributeArgument(
new CodeVariableReferenceExpression("\"" + prefix + "\"")));
typeDecl.CustomAttributes.Add(attrDecl);
// pump in the user specified code as a snippet
CodeSnippetTypeMember literalMember =
new CodeSnippetTypeMember(codeBody);
typeDecl.Members.Add( literalMember );
CodeNamespace nspace = new CodeNamespace();
//Add default imports
foreach (string nameSpace in ScriptTask._defaultNamespaces) {
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
foreach (string nameSpace in imports) {
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
compileUnit.Namespaces.Add( nspace );
nspace.Types.Add(typeDecl);
return compileUnit;
}
private void AddCodeSnippet(string codeText, int lineNum)
{
if (codeText == null || codeText.Trim().Length == 0)
return;
CodeSnippetTypeMember snippet = new CodeSnippetTypeMember();
AddLinePragma(snippet, lineNum);
snippet.Text = codeText;
_ccRoot.CodeClass.Members.Add(snippet);
}
protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
{
base.Output.Write(e.Text);
}
protected override void GenerateSnippetMember (CodeSnippetTypeMember e)
{
}
protected override void GenerateSnippetMember (CodeSnippetTypeMember member)
{
Output.Write (member.Text);
}
/*
* Build various properties, fields, methods
*/
protected virtual void BuildMiscClassMembers() {
// Build the Profile property
if (NeedProfileProperty)
BuildProfileProperty();
// Skip the rest if we're only generating the intermediate class
if (_sourceDataClass == null)
return;
// Build the injected properties from the global.asax <object> tags
BuildApplicationObjectProperties();
BuildSessionObjectProperties();
// Build the injected properties for objects scoped to the page
BuildPageObjectProperties();
// Add all the <script runat=server> code blocks
foreach (ScriptBlockData script in Parser.ScriptList) {
// Pad the code block so its generated offset matches the aspx
string code = script.Script;
code = code.PadLeft(code.Length + script.Column - 1);
CodeSnippetTypeMember literal = new CodeSnippetTypeMember(code);
literal.LinePragma = CreateCodeLinePragma(script.VirtualPath, script.Line,
script.Column, script.Column, script.Script.Length, false);
_sourceDataClass.Members.Add(literal);
}
}
protected override void GenerateSnippetMember(System.CodeDom.CodeSnippetTypeMember e)
{
throw new Exception("The method or operation is not implemented.");
}
/// <summary>
/// Generates the tracking changes classes.
/// </summary>
/// <returns></returns>
public static IEnumerable<CodeTypeDeclaration> GenerateTrackingChangesClasses()
{
var classList = new List<CodeTypeDeclaration>();
classList.Add(CreateObjectsToCollectionProperties("ObjectsOriginalFromCollectionProperties", "Dictionary<string, ObjectList>"));
classList.Add(CreateObjectsToCollectionProperties("ObjectsAddedToCollectionProperties", "Dictionary<string, ObjectList>"));
classList.Add(CreateObjectsToCollectionProperties("ObjectsRemovedFromCollectionProperties", "Dictionary<string, ObjectList>"));
classList.Add(CreateObjectsToCollectionProperties("PropertyValueStatesDictionary", "Dictionary<string, PropertyValueState>"));
// TrackableCollection
var trackableCollectionClass = new CodeTypeDeclaration("TrackableCollection")
{
IsClass = true,
IsPartial = false,
TypeAttributes = TypeAttributes.Public,
};
trackableCollectionClass.TypeParameters.Add(new CodeTypeParameter("T"));
var ctr = new CodeTypeReference("ObservableCollection");
ctr.TypeArguments.Add("T");
trackableCollectionClass.BaseTypes.Add(ctr);
var codeTemplate = new CodeSnippetTypeMember();
codeTemplate.Text = Resources.TrackableCollection_cs;
trackableCollectionClass.Members.Add(codeTemplate);
trackableCollectionClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "TrackableCollection class"));
trackableCollectionClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "TrackableCollection"));
classList.Add(trackableCollectionClass);
// ObjectChangeTracker class
var trackableClass = new CodeTypeDeclaration("ObjectChangeTracker")
{
IsClass = true,
IsPartial = false,
TypeAttributes = TypeAttributes.Public,
};
trackableClass.BaseTypes.Add(typeof(INotifyPropertyChanged));
var cm = new CodeSnippetTypeMember();
cm.Text = Resources.ObjectChangeTracker_cs;
trackableClass.Members.Add(cm);
trackableClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tracking changes class"));
trackableClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tracking changes class"));
classList.Add(trackableClass);
var notifyTrackableDelegate = new CodeTypeDelegate("NotifyTrackableCollectionChangedEventHandler");
notifyTrackableDelegate.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "sender"));
notifyTrackableDelegate.Parameters.Add(new CodeParameterDeclarationExpression("NotifyCollectionChangedEventArgs", "e"));
notifyTrackableDelegate.Parameters.Add(new CodeParameterDeclarationExpression("system.string", "propertyName"));
notifyTrackableDelegate.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "NotifyTrackableCollectionChangedEventHandler class"));
notifyTrackableDelegate.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "NotifyTrackableCollectionChangedEventHandler"));
classList.Add(notifyTrackableDelegate);
// enum ObjectState
var objectStateenum = new CodeTypeDeclaration("ObjectState")
{
IsEnum = true,
TypeAttributes = TypeAttributes.Public
};
// Creates the enum member
objectStateenum.Members.Add(new CodeMemberField(typeof(int), "Unchanged"));
objectStateenum.Members.Add(new CodeMemberField(typeof(int), "Added"));
objectStateenum.Members.Add(new CodeMemberField(typeof(int), "Modified"));
objectStateenum.Members.Add(new CodeMemberField(typeof(int), "Deleted"));
objectStateenum.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "ObjectState enum"));
objectStateenum.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "ObjectState"));
classList.Add(objectStateenum);
// ObjectList class
var ObjectListClass = new CodeTypeDeclaration("ObjectList")
{
IsClass = true,
IsPartial = false,
TypeAttributes = TypeAttributes.Public,
};
ctr = new CodeTypeReference("List");
ctr.TypeArguments.Add(typeof(object));
ObjectListClass.BaseTypes.Add(ctr);
ObjectListClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "ObjectList class"));
ObjectListClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "ObjectList"));
classList.Add(ObjectListClass);
// ObjectStateChangingEventArgs class
var objectStateChangingEventArgsClass = new CodeTypeDeclaration("ObjectStateChangingEventArgs")
{
IsClass = true,
IsPartial = false,
TypeAttributes = TypeAttributes.Public,
};
ctr = new CodeTypeReference("EventArgs");
objectStateChangingEventArgsClass.BaseTypes.Add(ctr);
codeTemplate = new CodeSnippetTypeMember();
codeTemplate.Text = Resources.ObjectStateChangingEventArgs_cs;
objectStateChangingEventArgsClass.Members.Add(codeTemplate);
objectStateChangingEventArgsClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "ObjectStateChangingEventArgs class"));
objectStateChangingEventArgsClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "ObjectStateChangingEventArgs"));
classList.Add(objectStateChangingEventArgsClass);
// ObjectChangeTracker class
var propertyValueStateClass = new CodeTypeDeclaration("PropertyValueState")
{
IsClass = true,
IsPartial = false,
TypeAttributes = TypeAttributes.Public,
};
cm = new CodeSnippetTypeMember();
cm.Text = Resources.PropertyValueState_cs;
propertyValueStateClass.Members.Add(cm);
propertyValueStateClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "PropertyValueState class"));
propertyValueStateClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "PropertyValueState class"));
classList.Add(propertyValueStateClass);
return classList;
}
private static CodeTypeDeclaration GenerateEntity(this Entity entity)
{
var type = new CodeTypeDeclaration(entity.Name)
{
TypeAttributes = TypeAttributes.Public,
Attributes = MemberAttributes.Public
};
foreach (var i in entity.Interfaces.Where(x => !string.IsNullOrEmpty(x.Name)))
{
type.BaseTypes.Add(new CodeTypeReference(i.Name.Trim()));
}
var properties = new List<MessageProperty>(entity.Properties);
foreach (var prop in properties.OrderBy(x => x.Optional))
{
var camelCased = prop.Name.CamelCased();
var pascalCased = prop.Name.PascalCased();
var property = new CodeSnippetTypeMember
{
Text = $"public {prop.Type.SafeTypeName()} {pascalCased} "
};
property.Text += "{ get; set; }\n";
type.Members.Add(property);
}
var expression = new Regex(@"\{(.+?)\}", RegexOptions.IgnoreCase | RegexOptions.Multiline);
if (!string.IsNullOrEmpty(entity.StringFormat))
{
var args = new List<CodeExpression>();
var index = 0;
foreach (Match match in expression.Matches(entity.StringFormat))
{
entity.StringFormat = entity.StringFormat.Replace(match.ToString(), "{" + index++ + "}");
var propertyName = match.Groups[1].Value.PascalCased();
args.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), propertyName));
}
args.Insert(0, new CodePrimitiveExpression(entity.StringFormat));
type.Members.Add(new CodeMemberMethod
{
Name = "ToString",
ReturnType = new CodeTypeReference(typeof(string)),
Attributes = MemberAttributes.Override | MemberAttributes.Public,
Statements =
{
new CodeMethodReturnStatement
{
Expression =
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof (string)),
"Format", args.ToArray())
}
}
});
}
type.Members.Add(entity.AddSetPropertiesMethod(SetPropertiesType.Properties));
return type;
}
protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
{
Output.WriteLine("[CodeSnippetTypeMember: {0}]", e.ToString());
}
// Add a new DryadLinqFactory subclass for a type
internal void AddFactoryClass(Type type)
{
Type baseClass = typeof(DryadLinqFactory<>).MakeGenericType(type);
string baseClassName = TypeSystem.TypeName(baseClass, this.AnonymousTypeToName);
CodeTypeDeclaration factoryClass = new CodeTypeDeclaration(DryadLinqFactoryClassName(type) + " : " + baseClassName);
this.m_dryadCodeSpace.Types.Add(factoryClass);
factoryClass.IsClass = true;
factoryClass.TypeAttributes = TypeAttributes.Public;
// Add method MakeReader(IntPtr handle, UInt32 port):
Type returnType = typeof(DryadLinqRecordReader<>).MakeGenericType(type);
string returnTypeName = TypeSystem.TypeName(returnType, this.AnonymousTypeToName);
StringBuilder mb1 = new StringBuilder();
mb1.AppendLine(" public override " + returnTypeName + " MakeReader(System.IntPtr handle, uint port)");
mb1.AppendLine(" {");
mb1.AppendLine(" return new " + DryadReaderClassName(type) +
"(Microsoft.Research.DryadLinq.Internal.VertexEnv.MakeBinaryReader(handle, port));");
mb1.AppendLine(" }");
CodeTypeMember readerMethod1 = new CodeSnippetTypeMember(mb1.ToString());
factoryClass.Members.Add(readerMethod1);
// Add method MakeReader(NativeBlockStream stream):
StringBuilder mb3 = new StringBuilder();
mb3.AppendLine(" public override " + returnTypeName +
" MakeReader(Microsoft.Research.DryadLinq.Internal.NativeBlockStream stream)");
mb3.AppendLine(" {");
mb3.AppendLine(" return new " + DryadReaderClassName(type) +
"(Microsoft.Research.DryadLinq.Internal.VertexEnv.MakeBinaryReader(stream));");
mb3.AppendLine(" }");
CodeTypeMember readerMethod3 = new CodeSnippetTypeMember(mb3.ToString());
factoryClass.Members.Add(readerMethod3);
// Add method MakeWriter(IntPtr handle, UInt32 port, Int32 buffSize):
returnType = typeof(DryadLinqRecordWriter<>).MakeGenericType(type);
returnTypeName = TypeSystem.TypeName(returnType, this.AnonymousTypeToName);
StringBuilder mb4 = new StringBuilder();
mb4.AppendLine(" public override " + returnTypeName + " MakeWriter(System.IntPtr handle, uint port, int buffSize)");
mb4.AppendLine(" {");
mb4.AppendLine(" return new " + DryadWriterClassName(type) +
"(Microsoft.Research.DryadLinq.Internal.VertexEnv.MakeBinaryWriter(handle, port, buffSize));");
mb4.AppendLine(" }");
CodeTypeMember writerMethod1 = new CodeSnippetTypeMember(mb4.ToString());
factoryClass.Members.Add(writerMethod1);
// Add method MakeWriter(NativeBlockStream stream):
StringBuilder mb6 = new StringBuilder();
mb6.AppendLine(" public override " + returnTypeName + " MakeWriter(Microsoft.Research.DryadLinq.Internal.NativeBlockStream stream)");
mb6.AppendLine(" {");
mb6.AppendLine(" return new " + DryadWriterClassName(type) +
"(Microsoft.Research.DryadLinq.Internal.VertexEnv.MakeBinaryWriter(stream));");
mb6.AppendLine(" }");
CodeTypeMember writerMethod3 = new CodeSnippetTypeMember(mb6.ToString());
factoryClass.Members.Add(writerMethod3);
}
internal void AddScript(string source, ScriptingLanguage lang, string ns, string fileName, int lineNumber)
{
ValidateExtensionNamespace(ns);
for (ScriptingLanguage langTmp = ScriptingLanguage.JScript; langTmp <= ScriptingLanguage.CSharp; langTmp++)
{
Hashtable typeDecls = _typeDeclsByLang[(int)langTmp];
if (lang == langTmp)
{
CodeTypeDeclaration scriptClass = (CodeTypeDeclaration)typeDecls[ns];
if (scriptClass == null)
{
scriptClass = new CodeTypeDeclaration(GenerateUniqueClassName());
scriptClass.TypeAttributes = TypeAttributes.Public;
typeDecls.Add(ns, scriptClass);
}
CodeSnippetTypeMember scriptSnippet = new CodeSnippetTypeMember(source);
if (lineNumber > 0)
{
scriptSnippet.LinePragma = new CodeLinePragma(fileName, lineNumber);
_scriptFiles.Add(fileName);
}
scriptClass.Members.Add(scriptSnippet);
}
else if (typeDecls.Contains(ns))
{
throw XsltException.Create(SR.Xslt_ScriptMixedLanguages, ns);
}
}
}
public void Visit (CodeSnippetTypeMember o)
{
g.GenerateSnippetMember (o);
}
public CodeCompileUnit GenerateCode(string typeName, string codeBody,
ITaskItem[] imports)
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(typeName);
typeDecl.IsClass = true;
typeDecl.TypeAttributes = TypeAttributes.Public;
// pump in the user specified code as a snippet
CodeSnippetTypeMember literalMember =
new CodeSnippetTypeMember(codeBody);
typeDecl.Members.Add(literalMember);
CodeNamespace nspace = new CodeNamespace();
//Add default imports
foreach (string nameSpace in Script._defaultNamespaces)
{
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
if (imports != null)
{
foreach (ITaskItem item in imports)
{
string nameSpace = item.ItemSpec;
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
}
compileUnit.Namespaces.Add(nspace);
nspace.Types.Add(typeDecl);
return compileUnit;
}
protected abstract void GenerateSnippetMember (CodeSnippetTypeMember m);
