private void ImplementIContainsMixin(
CodeGeneratorProxy codeBehind,
MixinGenerationPlan mgp)
{
var containMixinInterfaceName =
string.Format(
"global::{0}.{1}<{2}>",
typeof(IContainMixin <>).Namespace,
"IContainMixin",
mgp.MixinAttribute.Mixin.GetOriginalFullNameWithGlobal());
codeBehind.ImplementInterface(
containMixinInterfaceName);
codeBehind.CreateProperty(
modifier:
//implement explicitly
string.Empty,
returnTypeFullName:
mgp.MixinAttribute.Mixin.GetOriginalFullNameWithGlobal(),
propertyName:
containMixinInterfaceName + ".MixinInstance",
getterMethodBody:
string.Format(
"get{{ return {0}.{1}; }}",
mgp.MasterWrapperPlan.MasterWrapperInstanceNameAvailableFromTargetCodeBehind,
MasterWrapperPlan.MixinInstanceDataMemberName),
setterMethodBody:
//no setter
string.Empty
);
}
private void ProcessAbstractMembers(
pMixinGeneratorPipelineState manager, CodeGeneratorProxy requirementInterface)
{
foreach (var abstractMember in manager.CurrentMixinMembers
.GetUnimplementedAbstractMembers())
{
#region Process Methods
if (abstractMember is IMethod)
{
requirementInterface.CreateMethod(
string.Empty, //no modifier for interface member
abstractMember.ReturnType.GetOriginalFullNameWithGlobal(),
GetAbstractMemberImplementationName(abstractMember),
(abstractMember as IMethod).Parameters.ToKeyValuePair(),
string.Empty,
(abstractMember as IMethod).GetGenericMethodConstraints(
manager.BaseState.Context.TypeResolver.Compilation));
}
#endregion
#region Process Properties
else if (abstractMember is IProperty)
{
requirementInterface.CreateProperty(
string.Empty, //no modifier for interface member
abstractMember.ReturnType.GetOriginalFullNameWithGlobal(),
GetAbstractMemberImplementationName(abstractMember),
(abstractMember as IProperty).CanGet ? "get;" : "",
(abstractMember as IProperty).CanSet ? "set;" : "");
}
#endregion
}
}
private void AddActivateMixinDependenciesMethod(CodeGeneratorProxy mixinsClassCodeGenerator, TargetLevelCodeGeneratorPipelineState manager)
{
const string targetInstanceMethodParameterName = "target";
var methodBodyStatements = new StringBuilder();
foreach (var mixin in manager.CodeGenerationPlan.MixinGenerationPlans.Values)
{
methodBodyStatements.AppendFormat(
"{0}.{1}({2};",
mixin.MasterWrapperPlan.MasterWrapperInstanceNameInMixinsContainer,
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsActivateMixinDependenciesMethodName,
targetInstanceMethodParameterName);
}
mixinsClassCodeGenerator.CreateMethod(
modifier:
"public",
returnTypeFullName:
"void",
methodName:
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsActivateMixinDependenciesMethodName,
parameters:
new[]
{
new KeyValuePair <string, string>(
manager.TargetSourceTypeDeclaration.GetFullTypeName(),
targetInstanceMethodParameterName)
},
methodBody:
methodBodyStatements.ToString());
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var targetCodeBehind =
new TypeDeclaration
{
ClassType = ClassType.Class,
Modifiers = manager.TargetSourceTypeDeclaration.Modifiers, // this should include partial
Name = manager.TargetSourceTypeDeclaration.Name
};
var codeGenerator =
new CodeGeneratorProxy(
targetCodeBehind,
addCodeGeneratedAttribute: true);
//implement TargetCodeBehindPlan.MixinInterfaces
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinInterfaces
.Map(i => codeGenerator.ImplementInterface(i.GetOriginalFullNameWithGlobal()));
//Save targetCodeBehind to state
manager.TargetCodeBehindTypeDeclaration = targetCodeBehind;
//Add targetCodeGehind to Syntax Tree
manager.CodeBehindSyntaxTree.AddChildTypeDeclaration
(targetCodeBehind,
manager.TargetSourceTypeDeclaration.GetParent <NamespaceDeclaration>());
return(true);
}
private void GenerateConstructor(CodeGeneratorProxy codeGenerator, MixinLevelCodeGeneratorPipelineState manager)
{
var constructorBodyStatements = new StringBuilder();
#region Mixin Instance Initialization Statement
constructorBodyStatements.AppendFormat(
"{0} = {1}",
MasterWrapperPlan.MixinInstanceDataMemberName,
manager.MixinGenerationPlan.MasterWrapperPlan.MixinInstanceInitializationStatement
.EnsureEndsWith(";"));
#endregion
#region Initialize Virtual Member Functions
var masterWrapperMemberHelper =
new MasterWrapperCodeGeneratorProxyMemberHelper(
codeGenerator,
manager.CommonState.Context.TypeResolver.Compilation);
manager.MixinGenerationPlan.MasterWrapperPlan.VirtualMembers.
Map(mw => constructorBodyStatements.Append(
GenerateVirtualMemberFunctionInitializationStatement(mw, masterWrapperMemberHelper)));
#endregion
#region Initialize BaseMasterWrapper Statement
constructorBodyStatements.AppendFormat(
"base.Initialize( {0}, {1}, new global::System.Collections.Generic.List<global::{2}>{{ {3} }});",
MasterWrapperPlan.TargetInstanceConstructorParameterName,
MasterWrapperPlan.MixinInstanceDataMemberName,
typeof(IMixinInterceptor).GetOriginalFullName(),
string.Join(",",
manager.MixinGenerationPlan.MixinAttribute.Interceptors
.Select <IType, string>(x => x.GenerateActivationExpression())
)
);
#endregion
codeGenerator.CreateConstructor(
modifiers:
"public",
parameters:
new[]
{
new KeyValuePair <string, string>(
manager.MixinGenerationPlan.ExternalMixinSpecificAutoGeneratedNamespaceName.EnsureEndsWith(
".") +
manager.MixinGenerationPlan.RequirementsInterfacePlan.RequirementsInterfaceName,
MasterWrapperPlan.TargetInstanceConstructorParameterName)
},
constructorInitializer:
string.Empty,
constructorBody:
constructorBodyStatements.ToString());
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
var codeGenerator = new CodeGeneratorProxy(manager.MasterWrapper);
CreateActivateDependencyMethod(codeGenerator, manager.MixinGenerationPlan);
return(true);
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var codeGenerator =
new CodeGeneratorProxy(manager.TargetCodeBehindTypeDeclaration);
var backingFiledName = "__" + manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsPropertyName;
//create backing field
codeGenerator.CreateDataMember(
modifiers:
"private",
dataMemberTypeFullName:
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsClassName,
dataMemberName:
backingFiledName
);
//create private property
codeGenerator.CreateProperty(
modifier:
"private",
returnTypeFullName:
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsClassName,
propertyName:
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsPropertyName,
getterMethodBody:
string.Format(
@"
get
{{
if (null == {0})
{{
lock({1}.{2})
{{
if (null == {0})
{{
{0} = new {1}(this);
{0}.{3}(this);
}}
}}
}}
return {0};
}}
",
backingFiledName,
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsClassName,
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsLockVariableName,
manager.CodeGenerationPlan.TargetCodeBehindPlan.MixinsActivateMixinDependenciesMethodName)
,
setterMethodBody:
string.Empty //no setter
);
return(true);
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
var codeGenerator = new CodeGeneratorProxy(manager.MasterWrapper);
GenerateMixinInstanceDataMember(codeGenerator, manager);
GenerateVirtualFuncDataMembers(codeGenerator, manager);
return(true);
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
var codeGenerator = new CodeGeneratorProxy(manager.MasterWrapper);
GenerateConstructor(codeGenerator, manager);
return(true);
}
private void GenerateMixinInstanceDataMember(CodeGeneratorProxy codeGenerator, MixinLevelCodeGeneratorPipelineState manager)
{
codeGenerator.CreateDataMember(
modifiers:
//must be public for implicit conversion operator
"public",
dataMemberTypeFullName:
manager.MixinGenerationPlan.MasterWrapperPlan.MixinInstanceTypeFullName,
dataMemberName:
MasterWrapperPlan.MixinInstanceDataMemberName);
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var codeGeneratorProxy =
new CodeGeneratorProxy(manager.TargetCodeBehindTypeDeclaration);
manager.CodeGenerationPlan.MixinGenerationPlans.Values
.Where(mgp => mgp.AddAnIContainsMixinImplementation)
.Map(mgp => ImplementIContainsMixin(codeGeneratorProxy, mgp));
return(true);
}
private void AddLockDataMember(CodeGeneratorProxy mixinsClassCodeGenerator, CodeGenerationPlan codeGenerationPlan)
{
mixinsClassCodeGenerator.CreateDataMember(
modifiers:
"public static",
dataMemberTypeFullName:
"global::System.Object",
dataMemberName:
codeGenerationPlan.TargetCodeBehindPlan.MixinsLockVariableName,
initializerExpression:
"= new global::System.Object();");
}
private void AddMixinDataMembers(CodeGeneratorProxy mixinsClassCodeGenerator, TargetLevelCodeGeneratorPipelineState manager)
{
foreach (var mixin in manager.CodeGenerationPlan.MixinGenerationPlans.Values)
{
mixinsClassCodeGenerator.CreateDataMember(
modifiers:
"public",
dataMemberTypeFullName:
GetMasterWrapperFullTypeName(mixin),
dataMemberName:
mixin.MasterWrapperPlan.MasterWrapperInstanceNameInMixinsContainer);
}
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
var targetCodeBehindCodeGeneratorProxy =
new CodeGeneratorProxy(
manager.TargetLevelCodeGeneratorPipelineState.TargetCodeBehindTypeDeclaration);
GenerateMembers(
manager,
targetCodeBehindCodeGeneratorProxy,
manager.MixinGenerationPlan.MembersPromotedToTarget);
return(true);
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var codeGeneratorProxy =
new CodeGeneratorProxy(manager.TargetCodeBehindTypeDeclaration);
foreach (var mixinPlan in manager.CodeGenerationPlan.MixinGenerationPlans.Values)
{
codeGeneratorProxy.ImplementInterface(
mixinPlan.ExternalMixinSpecificAutoGeneratedNamespaceName.EnsureEndsWith(".") +
mixinPlan.RequirementsInterfacePlan.RequirementsInterfaceName);
}
return(true);
}
public bool PerformTask(pMixinGeneratorPipelineState manager)
{
if (manager.CurrentpMixinAttribute.Mixin.IsStaticOrSealed())
{
return(true);
}
var wrapperClassDeclaration = new TypeDeclaration
{
ClassType = ClassType.Class,
Modifiers = GenerateProtectedMixinMembersWrapperClass.GetMixinTypeModifiers(manager),
Name = GetWrapperClassName(manager)
};
var simpleType = new SimpleType(
(Identifier)
manager.CurrentMixinProtectedMembersWrapperClass.Descendants.OfType <Identifier>().First().Clone());
wrapperClassDeclaration.BaseTypes.Add(simpleType);
manager.CurrentMixinAbstractMembersWrapperClass = wrapperClassDeclaration;
ICodeGeneratorProxy wrapperClass;
if (manager.CurrentpMixinAttribute.Mixin.GetDefinition().IsAbstract)
{
//Protected/Abstract Wrappers will all be created in the external
//namespace (Mixin is not allowed to be private)
manager.BaseState.GeneratedCodeSyntaxTree.AddChildTypeDeclaration(
wrapperClassDeclaration,
new NamespaceDeclaration(ExternalGeneratedNamespaceHelper.GenerateNamespace(manager)));
wrapperClass = new CodeGeneratorProxy(wrapperClassDeclaration, "");
}
else
{
//Protected/Abstract Wrappers will all be created as
//a nested type inside Target (in case Mixin is private)
wrapperClass = manager.CurrentAutoGeneratedTypeDeclaration.AddNestedType(wrapperClassDeclaration);
}
CreateRequirementsDataMemberAndConstructor(wrapperClass, manager);
ProcessMembers(wrapperClass, manager);
return(true);
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var mixinsClassCodeGenerator =
new CodeGeneratorProxy(manager.MixinsClassInTargetCodeBehind);
AddLockDataMember(mixinsClassCodeGenerator, manager.CodeGenerationPlan);
AddMixinDataMembers(mixinsClassCodeGenerator, manager);
AddConstructor(mixinsClassCodeGenerator, manager);
AddActivateMixinDependenciesMethod(mixinsClassCodeGenerator, manager);
return(true);
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
if (!manager.MixinGenerationPlan.ProtectedWrapperPlan.GenrateProtectedWrapper)
{
return(true);
}
var codeGenerator =
new CodeGeneratorProxy(manager.ProtectedMembersWrapper);
ProcessConstructors(codeGenerator, manager);
ProcessMembers(codeGenerator, manager);
return(true);
}
/// <summary>
/// Creates simple public constructors that pass all parameters to base.
/// <code>
/// <![CDATA[
/// public ProtectedWrapper(obj p1, obj p2) : base (p1, p2){}
/// ]]></code>
/// </summary>
/// <param name="codeGenerator"></param>
/// <param name="manager"></param>
private void ProcessConstructors(CodeGeneratorProxy codeGenerator, MixinLevelCodeGeneratorPipelineState manager)
{
manager.MixinGenerationPlan.ProtectedWrapperPlan.Constructors
.Map(c =>
codeGenerator.CreateConstructor(
modifiers:
"public",
parameters:
c.Parameters.ToKeyValuePair(),
constructorInitializer:
": base(" + string.Join(",", c.Parameters.Select(p => p.Name)) + ")",
constructorBody:
string.Empty
)
);
}
public bool PerformTask(MixinLevelCodeGeneratorPipelineState manager)
{
if (!manager.MixinGenerationPlan.AbstractWrapperPlan.GenrateAbstractWrapper)
{
return(true);
}
var codeGenerator =
new CodeGeneratorProxy(manager.AbstractMembersWrapper);
CreateRequirementsDataMember(codeGenerator, manager);
CreateRequirementsDataMemberAndConstructor(codeGenerator, manager);
ProcessMembers(codeGenerator, manager);
return(true);
}
private void ProcessMembers(CodeGeneratorProxy codeGenerator, MixinLevelCodeGeneratorPipelineState manager)
{
var proxyMemberHelper =
new CodeGeneratorProxyMemberHelper(
codeGenerator,
manager.CommonState.Context.TypeResolver.Compilation);
proxyMemberHelper.CreateMembers(
members:
manager.MixinGenerationPlan.ProtectedWrapperPlan.Members,
generateMemberModifier:
m => "public new " + (m.Member.IsStatic ? " static" : ""),
baseObjectIdentifierFunc:
m =>
(m.Member.IsStatic)
? m.MixinAttribute.Mixin.GetOriginalFullNameWithGlobal()
: "base");
}
public bool PerformTask(pMixinGeneratorPipelineState manager)
{
if (manager.CurrentpMixinAttribute.Mixin.GetDefinition().IsStatic)
{
return(true);
}
//Create the TypeDeclaration
var requirementsInterfaceDeclaration =
new TypeDeclaration
{
ClassType = ClassType.Interface,
Modifiers = Modifiers.Public,
Name =
"I"
+ manager.CurrentpMixinAttribute.Mixin.GetNameAsIdentifier()
+ "Requirements"
};
var interfaceNamespace = ExternalGeneratedNamespaceHelper.GenerateNamespace(manager);
//Save the interface's FullName into the manager
manager.CurrentMixinRequirementsInterface =
interfaceNamespace
.EnsureStartsWith("global::").EnsureEndsWith(".") +
requirementsInterfaceDeclaration.Name;
//Add the TypeDeclaration to the Generated Code Tree
manager.BaseState.GeneratedCodeSyntaxTree.AddChildTypeDeclaration(
requirementsInterfaceDeclaration, new NamespaceDeclaration(interfaceNamespace));
//Create the Code Generator
var requirementInterface = new CodeGeneratorProxy(
requirementsInterfaceDeclaration, "");
ProcessAbstractMembers(manager, requirementInterface);
//Have the Target implement mixinRequirementsInterface
manager.GeneratedClass.ImplementInterface(manager.CurrentMixinRequirementsInterface);
return(true);
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var codeGeneratorProxy =
new CodeGeneratorProxy(manager.TargetCodeBehindTypeDeclaration);
manager.CodeGenerationPlan.MixinGenerationPlans.Values
.Where(mgp => mgp.AddIMixinConstructorRequirementInterface)
.Map(mgp =>
codeGeneratorProxy.ImplementInterface(
string.Format("{0}.{1}<{2}>",
typeof(IMixinConstructorRequirement <>).Namespace,
"IMixinConstructorRequirement",
mgp.MasterWrapperPlan.MixinInstanceTypeFullName
)
)
);
return(true);
}
private void AddConstructor(CodeGeneratorProxy mixinsClassCodeGenerator, TargetLevelCodeGeneratorPipelineState manager)
{
const string targetInstanceConstructorParameterName = "target";
var constructorBodyStatements = new StringBuilder();
foreach (var mixin in manager.CodeGenerationPlan.MixinGenerationPlans.Values)
{
constructorBodyStatements.AppendFormat(
"{0} = {1};",
mixin.MasterWrapperPlan.MasterWrapperInstanceNameInMixinsContainer,
TypeExtensions.GenerateActivationExpression(
typeFullName:
GetMasterWrapperFullTypeName(mixin),
constructorArgs:
string.Format(
"({0}.{1}) {2}",
mixin.ExternalMixinSpecificAutoGeneratedNamespaceName,
mixin.RequirementsInterfacePlan.RequirementsInterfaceName,
targetInstanceConstructorParameterName))
);
}
mixinsClassCodeGenerator.CreateConstructor(
modifiers:
"public",
parameters:
new[]
{
new KeyValuePair <string, string>(
manager.TargetSourceTypeDeclaration.Name,
targetInstanceConstructorParameterName)
},
constructorInitializer:
string.Empty,
constructorBody:
constructorBodyStatements.ToString());
}
private void ProcessConstructors(pMixinGeneratorPipelineState manager, CodeGeneratorProxy requirementInterface)
{
bool hasANonParamaterlessConstructor =
manager.CurrentpMixinAttribute.Mixin.GetConstructors()
.Any(c => !c.Parameters.Any());
if (hasANonParamaterlessConstructor &&
!manager.CurrentpMixinAttribute.Mixin.GetDefinition().IsAbstract&&
!manager.CurrentpMixinAttribute.ExplicitlyInitializeMixin)
{
return;
}
//Update ExplicitlyInitializeMixin - Changed mind, user has to always set
//ExplicitlyInitializeMixin to true even if mixin does not have parameterless constructor.
//They could be using a custom MixinActivator that uses DI
//manager.CurrentpMixinAttribute.ExplicitlyInitializeMixin = true;
if (!manager.CurrentpMixinAttribute.ExplicitlyInitializeMixin)
{
return;
}
var requiredMixinWrapperType =
(manager.CurrentpMixinAttribute.Mixin.GetDefinition().IsAbstract)
? GenerateMixinSpecificAutoGeneratedClass.GetFullNameForChildType(
manager,
GenerateAbstractMixinMembersWrapperClass.GetWrapperClassName(manager))
: manager.CurrentpMixinAttribute.Mixin.GetOriginalFullNameWithGlobal();
//generate the mixin initialization method
requirementInterface.CreateMethod(
string.Empty, //no modifier for interface member
requiredMixinWrapperType,
GetInitializationMethod(manager),
new List <KeyValuePair <string, string> >(),
"");
}
private void CreateActivateDependencyMethod(CodeGeneratorProxy codeGenerator, MixinGenerationPlan mixinPlan)
{
const string targetInstanceMethodParameterName = "target";
var methodBodyStatements = new StringBuilder();
foreach (var dependency in mixinPlan.MasterWrapperPlan.MixinDependencies)
{
methodBodyStatements.AppendFormat(
@" (({0}){1}).Dependency = {2};
(({0}){1}).OnDependencySet();",
dependency.GetOriginalFullNameWithGlobal(),
MasterWrapperPlan.MixinInstanceDataMemberName,
targetInstanceMethodParameterName);
}
codeGenerator.CreateMethod(
modifier:
"public",
returnTypeFullName:
"void",
methodName:
mixinPlan.CodeGenerationPlan.TargetCodeBehindPlan.MixinsActivateMixinDependenciesMethodName,
parameters:
new[]
{
new KeyValuePair <string, string>(
mixinPlan.CodeGenerationPlan.SourceClass.GetFullTypeName(),
targetInstanceMethodParameterName)
},
methodBody:
methodBodyStatements.ToString()
//make sure method has at least an empty body
.IfEmpty("{}"));
}
public bool PerformTask(TargetLevelCodeGeneratorPipelineState manager)
{
var codeGenerator =
new CodeGeneratorProxy(manager.TargetCodeBehindTypeDeclaration);
const string targetInstanceMethodParameterName = "target";
foreach (var conversionPlan in manager.CodeGenerationPlan.TargetCodeBehindPlan.ImplicitCoversionPlans)
{
codeGenerator.CreateMethod(
modifier:
"public static implicit",
returnTypeFullName:
"operator",
methodName:
conversionPlan.ConversionTargetType.GetOriginalFullNameWithGlobal(),
parameters:
new []
{
new KeyValuePair <string, string>(
manager.TargetCodeBehindTypeDeclaration.Name,
targetInstanceMethodParameterName)
},
methodBody:
string.Format(
"return {0}.{1}.{2};",
targetInstanceMethodParameterName,
conversionPlan.MixinGenerationPlan.MasterWrapperPlan
.MasterWrapperInstanceNameAvailableFromTargetCodeBehind,
MasterWrapperPlan.MixinInstanceDataMemberName)
);
}
return(true);
}
private void GenerateVirtualFuncDataMembers(CodeGeneratorProxy codeGenerator, MixinLevelCodeGeneratorPipelineState manager)
{
foreach (var mw in manager.MixinGenerationPlan.MasterWrapperPlan.VirtualMembers)
{
if (mw.Member is IMethod)
{
var virtualFuncReturnType =
(mw.Member as IMethod).ReturnType.Kind == TypeKind.Void
? typeof(Action).GetOriginalFullNameWithGlobal()
: string.Format("global::System.Func<{0}>",
string.Join(",",
(mw.Member as IMethod).Parameters
.Select(x => x.Type.GetOriginalFullNameWithGlobal())
.Concat(new[] { mw.Member.ReturnType.GetOriginalFullNameWithGlobal() })));
codeGenerator.CreateProperty(
modifier:
"public",
returnTypeFullName:
virtualFuncReturnType,
propertyName:
mw.ImplementationDetails.VirtualMemberFunctionName,
getterMethodBody:
"get;",
setterMethodBody:
"set;");
}
else if (mw.Member is IProperty)
{
//Get
if ((mw.Member as IProperty).CanGet && !(mw.Member as IProperty).Getter.IsPrivate)
{
codeGenerator.CreateProperty(
modifier:
"public",
returnTypeFullName:
"global::System.Func<" + mw.Member.ReturnType.GetOriginalFullNameWithGlobal() + ">",
propertyName:
mw.ImplementationDetails.VirtualMemberFunctionName + "Get",
getterMethodBody:
"get;",
setterMethodBody:
"set;");
}
//Set
if ((mw.Member as IProperty).CanSet && !(mw.Member as IProperty).Setter.IsPrivate)
{
codeGenerator.CreateProperty(
modifier:
"public",
returnTypeFullName:
"global::System.Action<" + mw.Member.ReturnType.GetOriginalFullNameWithGlobal() + ">",
propertyName:
mw.ImplementationDetails.VirtualMemberFunctionName + "Set",
getterMethodBody:
"get;",
setterMethodBody:
"set;");
}
}
}
}
