/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField"></param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
ItemsControl itemsControl = source as ItemsControl;
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemsPanelProperty);
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemTemplateProperty);
if (itemsControl.Items.Count > 0)
{
TypeGenerator typeGenerator = new TypeGenerator();
ValueGenerator valueGenerator = new ValueGenerator();
CodeMemberMethod itemsMethod = new CodeMemberMethod();
itemsMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private;
itemsMethod.Name = "Get_" + itemsControl.Name + "_Items";
itemsMethod.ReturnType = new CodeTypeReference(typeof(ObservableCollection<object>));
classType.Members.Add(itemsMethod);
CodeVariableDeclarationStatement collection = new CodeVariableDeclarationStatement(
typeof(ObservableCollection<object>), "items", new CodeObjectCreateExpression(typeof(ObservableCollection<object>)));
itemsMethod.Statements.Add(collection);
CodeVariableReferenceExpression itemsVar = new CodeVariableReferenceExpression("items");
foreach (var item in itemsControl.Items)
{
Type itemType = item.GetType();
CodeExpression itemExpr = null;
if (typeGenerator.HasGenerator(itemType))
{
itemExpr = typeGenerator.ProcessGenerators(item, classType, itemsMethod, false);
}
else
{
itemExpr = valueGenerator.ProcessGenerators(classType, itemsMethod, item, itemsControl.Name);
}
if (itemExpr != null)
{
CodeMethodInvokeExpression addItem = new CodeMethodInvokeExpression(itemsVar, "Add", itemExpr);
itemsMethod.Statements.Add(addItem);
}
else
{
CodeComHelper.GenerateError(itemsMethod, string.Format("Type {0} in Items Control collection not supported", itemType.Name));
}
}
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(itemsVar);
itemsMethod.Statements.Add(returnStatement);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "ItemsSource"),
new CodeMethodInvokeExpression(null, itemsMethod.Name)));
}
return fieldReference;
}
private static FakeChainFactory CreateFakeChainFactory(ProxyGenerator proxyGenerator, ValueGenerator valueGenerator)
{
return(new FakeChainFactory(
new CachedReturnValueGeneration(new PerMethodCache <object>()),
GlobalNestingLimit.Of(5),
proxyGenerator,
valueGenerator));
}
private void GenerateBehaviorActions(ActionCollection actionCollection, CodeTypeDeclaration classType, CodeMemberMethod method, CodeVariableReferenceExpression behaviorVarRef, string behaviorName)
{
for (int i = 0; i < actionCollection.Count; i++)
{
var action = actionCollection[i];
string actionName = behaviorName + "_ACT_" + i;
Type type = action.GetType();
CodeVariableDeclarationStatement variable = new CodeVariableDeclarationStatement(type.Name, actionName, new CodeObjectCreateExpression(type.Name));
method.Statements.Add(variable);
var actionVarRef = new CodeVariableReferenceExpression(actionName);
method.Statements.Add(new CodeMethodInvokeExpression(
behaviorVarRef, "Actions.Add", actionVarRef));
ValueGenerator valueGenerator = new ValueGenerator();
MethodInfo generateFieldMethod = typeof(CodeComHelper).GetMethod("GenerateField");
LocalValueEnumerator enumerator = action.GetLocalValueEnumerator();
while (enumerator.MoveNext())
{
LocalValueEntry entry = enumerator.Current;
DependencyProperty property = entry.Property;
Type valueType = entry.Value.GetType();
if (CodeComHelper.IsValidForFieldGenerator(entry.Value))
{
if (valueGenerator.Generators.ContainsKey(property.PropertyType) || valueGenerator.Generators.ContainsKey(valueType))
{
CodeExpression propValue = valueGenerator.ProcessGenerators(classType, method, entry.Value, actionName);
if (propValue != null)
{
method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(actionVarRef, property.Name), propValue));
}
}
else if (entry.Value is PropertyPath)
{
PropertyPath path = entry.Value as PropertyPath;
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(actionVarRef, property.Name),
new CodeObjectCreateExpression("PropertyPath", new CodePrimitiveExpression(path.Path))));
}
else if (entry.Value is SoundSource)
{
var soundSource = CodeComHelper.GenerateSoundSource(method, entry.Value as SoundSource);
method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(actionVarRef, property.Name), soundSource));
}
else
{
MethodInfo generic = generateFieldMethod.MakeGenericMethod(property.PropertyType);
if (generic == null)
{
throw new NullReferenceException("Generic method not created for type - " + property.PropertyType);
}
generic.Invoke(null, new object[] { method, actionVarRef, action, property });
}
}
}
CodeComHelper.GenerateBindings(method, actionVarRef, action, actionName, behaviorVarRef);
//CodeComHelper.GenerateResourceReferences(method, actionVarRef, action);
}
}
public void SetUp()
{
_generator = new ValueGenerator();
_list = new LinkedListNode <string>();
}
internal static List <MappingInfo> GetMetadata(DbContext context, Type type)
{
var metadata = context.Model;
var entityType = metadata.GetEntityTypes().Single(x => x.ClrType == type);
var tableName = GetTableName(context, type);
var columnsInfo = NpgsqlBulkUploader.RelationalHelper.GetColumnsInfo(context, tableName);
if (entityType.BaseType != null)
{
var baseTableName = GetTableName(context, entityType.BaseType.ClrType);
if (baseTableName != tableName)
{
var extraColumnsInfo = NpgsqlBulkUploader.RelationalHelper.GetColumnsInfo(context, baseTableName);
columnsInfo.AddRange(extraColumnsInfo);
}
}
int optinalIndex = 0;
var innerList = entityType
.GetProperties()
.Where(x => x.GetColumnName() != "xmin") // For now we don't support xmin
.Select(x =>
{
var relational = x.DeclaringEntityType;
ValueGenerator localGenerator = null;
bool isDbGenerated = false;
var generatorFactory = x.GetAnnotations().FirstOrDefault(a => a.Name == "ValueGeneratorFactory");
if (generatorFactory != null)
{
var valueGeneratorAccessor = generatorFactory.Value as Func <IProperty, IEntityType, ValueGenerator>;
localGenerator = valueGeneratorAccessor(x, x.DeclaringEntityType);
}
else if (x.GetAnnotations().Any(y => y.Name == "Relational:ComputedColumnSql"))
{
isDbGenerated = true;
}
else if (x.GetAnnotations().Any(y => y.Name == "Npgsql:ValueGenerationStrategy"))
{
isDbGenerated = true;
}
var indexes = ((Microsoft.EntityFrameworkCore.Metadata.Internal.Property)x).PropertyIndexes;
long optionalFlag = 0;
if (indexes.StoreGenerationIndex >= 0 && localGenerator == null)
{
optionalFlag = 1 << optinalIndex;
optinalIndex++;
}
return(new MappingInfo()
{
TableName = relational.GetTableName(),
TableNameQualified = NpgsqlHelper.GetQualifiedName(relational.GetTableName(), relational.GetSchema()),
Property = x.PropertyInfo,
ColumnInfo = columnsInfo.First(c => c.ColumnName == x.GetColumnName()),
LocalGenerator = localGenerator,
ValueConverter = x.GetValueConverter(),
IsKey = x.IsKey(),
IsInheritanceUsed = entityType.BaseType != null,
DbProperty = x,
DoUpdate = !isDbGenerated && x.PropertyInfo != null, // don't update shadow props
DoInsert = !isDbGenerated, // do insert of shadow props
ReadBack = indexes.StoreGenerationIndex >= 0,
IsSpecifiedFlag = optionalFlag
});
}).ToList();
return(innerList);
}
ValueGenerator CreateValueGenerator(XElement settingElement, SettingLimits settingLimits = null)
{
ValueGenerator outValueGenerator = null;
bool hasCreatedValueGenerator = false;
//Iterate through all elements.
IEnumerable <XElement> elements = settingElement.Elements();
foreach (XElement element in elements)
{
//Warn about more than one value element.
if (hasCreatedValueGenerator)
{
_errorCollection.AddInvalidElement(element);
continue;
}
//Handle value element.
ValueGeneratorTypes valueGeneratorType;
if (Enum.TryParse <ValueGeneratorTypes>(element.Name.LocalName, out valueGeneratorType))
{
switch (valueGeneratorType)
{
case ValueGeneratorTypes.Null:
outValueGenerator = null;
break;
case ValueGeneratorTypes.Constant:
outValueGenerator = CreateConstantValueGenerator(element);
break;
case ValueGeneratorTypes.Range:
outValueGenerator = CreateRangeValueGenerator(element);
break;
case ValueGeneratorTypes.Boolean:
outValueGenerator = CreateBooleanValueGenerator(element);
break;
case ValueGeneratorTypes.CoinFlip:
outValueGenerator = CreateCoinFlipValueGenerator(element);
break;
case ValueGeneratorTypes.WeightedSelector:
outValueGenerator = CreateWeightedSelectorValueGenerator(element, settingLimits);
break;
default:
_errorCollection.AddInvalidElement(element);
break;
}
hasCreatedValueGenerator = outValueGenerator != null || valueGeneratorType == ValueGeneratorTypes.Null;
if (outValueGenerator != null && settingLimits != null && !outValueGenerator.IsValueRangeWithinLimits(settingLimits))
{
_errorCollection.AddSettingOutsideLimits(element, settingLimits);
}
}
//Invalid element.
else
{
_errorCollection.AddInvalidElement(element);
}
}
return(outValueGenerator);
}
/// <summary>
/// Initializes a new instance of the <see cref="SaveChangesHelper" /> class.
/// </summary>
/// <param name="dbContext"> <see cref="DbContext" /> against which the requested query will be executed. </param>
/// <param name="request"> The <see cref="SaveChangesRequest" /> object from the client containing the updated entities. </param>
public SaveChangesHelper(DbContext dbContext, SaveChangesRequest request)
{
this.dbContext = dbContext;
var typeMap = this.dbContext.Model.GetEntityTypes().ToDictionary(x => x.DisplayName());
var stateManager = this.dbContext.GetService <IStateManager>();
var entityMaterializerSource = this.dbContext.GetService <IEntityMaterializerSource>();
// Materialize entities and add entries to dbContext
EntityEntry MaterializeAndTrackEntity(UpdateEntryDto dto)
{
IEntityType entityType = typeMap[dto.EntityTypeName];
object MaterializeEntity()
{
var valueBuffer = new ValueBuffer(dto.GetCurrentValues(entityType, request.Mapper));
var materializationContext = new MaterializationContext(valueBuffer, this.dbContext);
return(entityMaterializerSource.GetMaterializer(entityType).Invoke(materializationContext));
}
EntityEntry entry;
if (entityType.HasDefiningNavigation())
{
IKey key = entityType.DefiningEntityType.FindPrimaryKey();
object[] keyValues = dto.GetDelegatedIdentityKeys(request.Mapper, key);
// Here we assume that the owner entry is already present in the context
EntityEntry ownerEntry = stateManager.TryGetEntry(key, keyValues).ToEntityEntry();
ReferenceEntry referenceEntry = ownerEntry.Reference(entityType.DefiningNavigationName);
if (referenceEntry.CurrentValue == null)
{
referenceEntry.CurrentValue = MaterializeEntity();
}
entry = referenceEntry.TargetEntry;
}
else
{
entry = stateManager.GetOrCreateEntry(MaterializeEntity()).ToEntityEntry();
}
// Correlate properties of DTO and entry
var props = dto.JoinScalarProperties(entry, request.Mapper);
// Set Key properties
foreach (var p in props.Where(x => x.EfProperty.Metadata.IsKey()))
{
p.EfProperty.CurrentValue = p.CurrentValue;
if (p.EfProperty.Metadata.GetOriginalValueIndex() >= 0)
{
p.EfProperty.OriginalValue = p.OriginalValue;
}
}
// Set EntityState after PK values (temp or perm) are set.
// This will add entities to identity map.
entry.State = dto.EntityState;
// Set non key properties
foreach (var p in props.Where(x => !x.EfProperty.Metadata.IsKey()))
{
bool canSetCurrentValue =
p.EfProperty.Metadata.IsShadowProperty ||
p.EfProperty.Metadata.TryGetMemberInfo(forConstruction: false, forSet: true, out _, out _);
if (canSetCurrentValue)
{
p.EfProperty.CurrentValue = p.CurrentValue;
}
if (p.EfProperty.Metadata.GetOriginalValueIndex() >= 0 &&
p.EfProperty.OriginalValue != p.OriginalValue)
{
p.EfProperty.OriginalValue = p.OriginalValue;
}
if (canSetCurrentValue)
{
p.EfProperty.IsModified = p.DtoProperty.IsModified;
}
}
// Mark temporary property values
foreach (var p in props.Where(x => x.DtoProperty.IsTemporary))
{
p.EfProperty.IsTemporary = true;
}
return(entry);
}
request.SharedIdentityDataTransferObjects.ForEach(dto => MaterializeAndTrackEntity(dto));
var entries = request.DataTransferObjects.Select(MaterializeAndTrackEntity).ToList();
// Replace temporary PKs coming from client with generated values (e.g. HiLoSequence)
var valueGeneratorSelector = this.dbContext.GetService <IValueGeneratorSelector>();
foreach (EntityEntry entry in entries)
{
foreach (PropertyEntry tempPk in
entry.Properties.Where(p =>
p.IsTemporary &&
p.Metadata.IsKey() &&
p.Metadata.RequiresValueGenerator()).ToList())
{
ValueGenerator valueGenerator = valueGeneratorSelector.Select(tempPk.Metadata, entry.Metadata);
if (!valueGenerator.GeneratesTemporaryValues)
{
tempPk.CurrentValue = valueGenerator.Next(entry);
tempPk.IsTemporary = false;
}
}
}
this.Entries = entries.Select(e => e.GetInfrastructure()).ToList();
}
public int Roll(bool isCritical = false)
{
return((isCritical && Size > 1)
? ValueGenerator.RollDice(this) + ValueGenerator.RollDice(this)
: ValueGenerator.RollDice(this));
}
public async Task <IActionResult> Login([FromBody] LoginRequest request)
{
Response <RegisteredUserResponse> response = new Response <RegisteredUserResponse>();
try
{
if (!ModelState.IsValid)
{
var requestResponse = ApiResponseFormatter.RequestResponse(ModelState);
return(BadRequest(requestResponse));
}
User userCredentials;
DateTime dateRegistered;
using (var _context = new MiniSurveyContext())
{
userCredentials = await _context.Users.Where(x => x.EmailAddress == request.Email.Trim())
.FirstOrDefaultAsync();
}
if (userCredentials == null)
{
response = new Response <RegisteredUserResponse>
{
ResponseBody = new SuccessResponse <RegisteredUserResponse>
{
Data = null,
ResponseCode = "E001",
ResponseMessage = "Your email and password combination was incorrect, kindly try again later."
}
};
return(Unauthorized(response.ResponseBody));
}
bool isPassword = userCredentials != null && _cryptographyService.ValidateHash(request.Password, userCredentials.PasswordSalt, userCredentials.PasswordHash);
if (!isPassword)
{
response = new Response <RegisteredUserResponse>
{
ResponseBody = new SuccessResponse <RegisteredUserResponse>
{
Data = null,
ResponseCode = "E001",
ResponseMessage = "Your email and password combination was incorrect, kindly try again later."
}
};
return(Unauthorized(response.ResponseBody));
}
var identity = _jwtFactory.GenerateClaimsIdentity(userCredentials.EmailAddress, userCredentials.Id.ToString());
var jwtToken = await ValueGenerator.GenerateJwt(identity, _jwtFactory, userCredentials.EmailAddress, _jwtOptions.Value, new JsonSerializerSettings { Formatting = Formatting.None });
// deserialize generated auth token to be passed to client application.
var authToken = JsonConvert.DeserializeObject <Token>(jwtToken);
response = new Response <RegisteredUserResponse>
{
ResponseBody = new SuccessResponse <RegisteredUserResponse>
{
Data = new RegisteredUserResponse {
User = new Dto.UserResponse {
Email = userCredentials.EmailAddress, Name = userCredentials.Name, DateRegistered = userCredentials.DateRegistered
}, Role = new DefaultResponse {
Id = userCredentials.RoleId, Value = HelperFunctions.GetRole(userCredentials.RoleId)
}
},
ResponseCode = "00",
ResponseMessage = "You have been successfully enrolled to participate in the survey."
}
};
return(Ok(response.ResponseBody));
}
catch (Exception)
{
response = new Response <RegisteredUserResponse>
{
ResponseBody = new SuccessResponse <RegisteredUserResponse>
{
Data = null,
ResponseCode = "E001",
ResponseMessage = "Sorry, we are unable to process your request at the moment, kindly try again later."
}
};
return(StatusCode(500, response.ResponseBody));
}
}
public string LiteralDataTest(object data)
{
var generator = new ValueGenerator();
return(generator.Generate(data));
}
private void GenerateBehaviorActions(ActionCollection actionCollection, CodeTypeDeclaration classType, CodeMemberMethod method, CodeVariableReferenceExpression behaviorVarRef, string behaviorName)
{
for (int i = 0; i < actionCollection.Count; i++)
{
var action = actionCollection[i];
string actionName = behaviorName + "_ACT_" + i;
Type type = action.GetType();
CodeVariableDeclarationStatement variable = new CodeVariableDeclarationStatement(type.Name, actionName, new CodeObjectCreateExpression(type.Name));
method.Statements.Add(variable);
var actionVarRef = new CodeVariableReferenceExpression(actionName);
method.Statements.Add(new CodeMethodInvokeExpression(
behaviorVarRef, "Actions.Add", actionVarRef));
ValueGenerator valueGenerator = new ValueGenerator();
MethodInfo generateFieldMethod = typeof(CodeComHelper).GetMethod("GenerateField");
LocalValueEnumerator enumerator = action.GetLocalValueEnumerator();
while (enumerator.MoveNext())
{
LocalValueEntry entry = enumerator.Current;
DependencyProperty property = entry.Property;
Type valueType = entry.Value.GetType();
if (CodeComHelper.IsValidForFieldGenerator(entry.Value))
{
if (valueGenerator.Generators.ContainsKey(property.PropertyType) || valueGenerator.Generators.ContainsKey(valueType))
{
CodeExpression propValue = valueGenerator.ProcessGenerators(classType, method, entry.Value, actionName);
if (propValue != null)
{
method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(actionVarRef, property.Name), propValue));
}
}
else if (entry.Value is PropertyPath)
{
PropertyPath path = entry.Value as PropertyPath;
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(actionVarRef, property.Name),
new CodeObjectCreateExpression("PropertyPath", new CodePrimitiveExpression(path.Path))));
}
else
{
MethodInfo generic = generateFieldMethod.MakeGenericMethod(property.PropertyType);
if (generic == null)
{
throw new NullReferenceException("Generic method not created for type - " + property.PropertyType);
}
generic.Invoke(null, new object[] { method, actionVarRef, action, property });
}
}
}
CodeComHelper.GenerateBindings(method, actionVarRef, action, actionName, behaviorVarRef);
//CodeComHelper.GenerateResourceReferences(method, actionVarRef, action);
}
}
private void GenerateBehaviors(BehaviorCollection behaviors, CodeTypeDeclaration classType, CodeMemberMethod method, FrameworkElement element, CodeExpression fieldReference)
{
for (int i = 0; i < behaviors.Count; i++)
{
var behavior = behaviors[i];
string behaviorName = element.Name + "_BEH_" + i;
Type type = behavior.GetType();
CodeVariableDeclarationStatement variable = new CodeVariableDeclarationStatement(type.Name, behaviorName, new CodeObjectCreateExpression(type.Name));
method.Statements.Add(variable);
var behaviorVarRef = new CodeVariableReferenceExpression(behaviorName);
method.Statements.Add(new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("Interaction"), "GetBehaviors(" + element.Name + ").Add", behaviorVarRef));
ValueGenerator valueGenerator = new ValueGenerator();
MethodInfo generateFieldMethod = typeof(CodeComHelper).GetMethod("GenerateField");
LocalValueEnumerator enumerator = behavior.GetLocalValueEnumerator();
while (enumerator.MoveNext())
{
LocalValueEntry entry = enumerator.Current;
DependencyProperty property = entry.Property;
Type valueType = entry.Value.GetType();
if (CodeComHelper.IsValidForFieldGenerator(entry.Value))
{
if (valueGenerator.Generators.ContainsKey(property.PropertyType) || valueGenerator.Generators.ContainsKey(valueType))
{
CodeExpression propValue = valueGenerator.ProcessGenerators(classType, method, entry.Value, behaviorName);
if (propValue != null)
{
method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(behaviorVarRef, property.Name), propValue));
}
}
else if (entry.Value is ActionCollection)
{
GenerateBehaviorActions(entry.Value as ActionCollection, classType, method, behaviorVarRef, behaviorName);
}
else
{
MethodInfo generic = generateFieldMethod.MakeGenericMethod(property.PropertyType);
if (generic == null)
{
throw new NullReferenceException("Generic method not created for type - " + property.PropertyType);
}
generic.Invoke(null, new object[] { method, behaviorVarRef, behavior, property });
}
}
}
CodeComHelper.GenerateBindings(method, behaviorVarRef, behavior, behaviorName);
CodeComHelper.GenerateResourceReferences(method, behaviorVarRef, behavior);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @MethodSource("validValueGenerators") void mustProduceValidMinimalSplittersWhenValuesAreEqual(ValueGenerator valueGenerator)
internal virtual void MustProduceValidMinimalSplittersWhenValuesAreEqual(ValueGenerator valueGenerator)
{
AssertValidMinimalSplitterForEqualValues(valueGenerator());
}
public ValueGeneratorTests()
{
generator = new ValueGenerator();
}
public WeaponsPerFunctionKeyGuarantee(ValueGenerator valueGenerator)
{
_valueGenerator = valueGenerator;
}
public void SetUp()
{
_valueGenerator = new ValueGenerator();
}
/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField"></param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
ItemsControl itemsControl = source as ItemsControl;
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemsPanelProperty);
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemTemplateProperty);
if (itemsControl.Items.Count > 0)
{
TypeGenerator typeGenerator = new TypeGenerator();
ValueGenerator valueGenerator = new ValueGenerator();
CodeMemberMethod itemsMethod = new CodeMemberMethod();
itemsMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private;
itemsMethod.Name = "Get_" + itemsControl.Name + "_Items";
itemsMethod.ReturnType = new CodeTypeReference(typeof(ObservableCollection <object>));
classType.Members.Add(itemsMethod);
CodeVariableDeclarationStatement collection = new CodeVariableDeclarationStatement(
typeof(ObservableCollection <object>), "items", new CodeObjectCreateExpression(typeof(ObservableCollection <object>)));
itemsMethod.Statements.Add(collection);
CodeVariableReferenceExpression itemsVar = new CodeVariableReferenceExpression("items");
foreach (var item in itemsControl.Items)
{
Type itemType = item.GetType();
CodeExpression itemExpr = null;
if (typeGenerator.HasGenerator(itemType))
{
itemExpr = typeGenerator.ProcessGenerators(item, classType, itemsMethod, false);
}
else
{
itemExpr = valueGenerator.ProcessGenerators(classType, itemsMethod, item, itemsControl.Name + "v" + uniqueId);
}
if (itemExpr != null)
{
CodeMethodInvokeExpression addItem = new CodeMethodInvokeExpression(itemsVar, "Add", itemExpr);
itemsMethod.Statements.Add(addItem);
}
else
{
CodeComHelper.GenerateError(itemsMethod, string.Format("Type {0} in Items Control collection not supported", itemType.Name));
}
uniqueId++;
}
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(itemsVar);
itemsMethod.Statements.Add(returnStatement);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "ItemsSource"),
new CodeMethodInvokeExpression(null, itemsMethod.Name)));
}
return(fieldReference);
}
