public ConversationAggregationResult TrackAggregation(string operationName, AggregationDelegate aggregation)
{
ConversationAggregationResult result;
using (this.CreateDiagnosticsFrame("ConversationAggregation", operationName))
{
try
{
result = aggregation(this.Logger);
}
catch (Exception value)
{
this.Logger.LogEvent(new SchemaBasedLogEvent <ConversationAggregationLogSchema.Error>
{
{
ConversationAggregationLogSchema.Error.Context,
base.GetType().Name
},
{
ConversationAggregationLogSchema.Error.Exception,
value
}
});
throw;
}
}
return(result);
}
public int AggregateCollection(List <int> original, AggregationDelegate aggregate)
{
int result = 0;
foreach (var item in original)
{
result = SumItems(result, item);
}
return(result);
}
static void Main(string[] args)
{
List <int> numbers = new List <int>()
{
55, 11, 5, 15, 21, 3, 5, 6, 7, 8, 13, 14
};
AggregationDelegate myDelegate = CalculateAvarage;
Console.WriteLine("Avarage : {0:F2}", AggregateCollection(numbers, myDelegate));
}
public int AggregateCollection(List<int> original, AggregationDelegate aggregate)
{
int result = 0;
foreach (var item in original)
{
result = SumItems(result, item);
}
return result;
}
static int AggregateCollection(List<int> original, AggregationDelegate<int> aggregate)
{
if (original.Count == 0) return 0;
if (original.Count == 1) return original[0];
int curAggregation = aggregate(original[0], original[1]);
if (original.Count == 1) return curAggregation;
for (int i = 2; i < original.Count; i++)
{
curAggregation = aggregate(curAggregation, original[i]);
}
return curAggregation;
}
public static T AggregateCollection <T>(this List <T> original, AggregationDelegate <T> aggregate)
{
if (original.Count <= 0)
{
throw new ArgumentException("List can't be empty");
}
var result = original[0];
for (var i = 1; i < original.Count; i++)
{
result = aggregate(result, original[i], i + 1);
}
return(result);
}
//public delegate void AnotherAggregationDelegate(List<int> numbers);
static void Main(string[] args)
{
var numbers = new List <int> {
2, 3, 14, 12, 19, 6, 4
};
AggregationDelegate myDelegate = CalculateAverage;
// Test void delegates
//AnotherAggregationDelegate mySecondDelegate = Min;
//mySecondDelegate += Max;
//mySecondDelegate += Sum;
//mySecondDelegate += Average;
Console.WriteLine("Average of numbers is {0}", AggregateCollection(numbers, myDelegate));
}
private ExpressionSyntax RewriteAsLoop(TypeSyntax returnType, IEnumerable <StatementSyntax> prologue, IEnumerable <StatementSyntax> epilogue, ExpressionSyntax collection, List <LinqStep> chain, AggregationDelegate k, bool noaggregation = false, IEnumerable <Tuple <ParameterSyntax, ExpressionSyntax> > additionalParameters = null)
{
var old = currentAggregation;
currentAggregation = k;
var collectionType = semantic.GetTypeInfo(collection).Type;
var collectionItemType = GetItemType(collectionType);
if (collectionItemType == null)
{
throw new NotSupportedException();
}
var collectionSemanticType = semantic.GetTypeInfo(collection).Type;
var parameters = new[] { CreateParameter(ItemsName, collectionSemanticType) }.Concat(currentFlow.Select(x => CreateParameter(x.Name, GetSymbolType(x.Symbol)).WithRef(x.Changes)));
if (additionalParameters != null)
{
parameters = parameters.Concat(additionalParameters.Select(x => x.Item1));
}
var functionName = GetUniqueName(currentMethodName + "_ProceduralLinq");
var arguments = CreateArguments(new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(ItemName)) }.Concat(currentFlow.Select(x => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(x.Name)).WithRef(x.Changes))));
var loopContent = CreateProcessingStep(chain, chain.Count - 1, SyntaxFactory.ParseTypeName(collectionItemType.ToDisplayString()), ItemName, arguments, noaggregation);
StatementSyntax foreachStatement;
if (collectionType.ToDisplayString().StartsWith("System.Collections.Generic.List<") || collectionType is IArrayTypeSymbol)
{
foreachStatement = SyntaxFactory.ForStatement(
SyntaxFactory.VariableDeclaration(CreatePrimitiveType(SyntaxKind.IntKeyword), CreateSeparatedList <VariableDeclaratorSyntax>(SyntaxFactory.VariableDeclarator("_index").WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)))))), default(SeparatedSyntaxList <ExpressionSyntax>),
SyntaxFactory.BinaryExpression(SyntaxKind.LessThanExpression, SyntaxFactory.IdentifierName("_index"), GetCollectionCount(collection, false)), CreateSeparatedList <ExpressionSyntax>(SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, SyntaxFactory.IdentifierName("_index"))),
SyntaxFactory.Block(new StatementSyntax[] { CreateLocalVariableDeclaration(ItemName, SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(ItemsName), SyntaxFactory.BracketedArgumentList(CreateSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("_index")))))) }.Union((loopContent as BlockSyntax)?.Statements ?? (IEnumerable <StatementSyntax>) new[] { loopContent })));
}
else
{
foreachStatement = SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
ItemName,
SyntaxFactory.IdentifierName(ItemsName),
loopContent is BlockSyntax ? loopContent : SyntaxFactory.Block(loopContent));
}
var coreFunction = SyntaxFactory.MethodDeclaration(returnType, functionName)
.WithParameterList(CreateParameters(parameters))
.WithBody(SyntaxFactory.Block((collectionSemanticType.IsValueType ? Enumerable.Empty <StatementSyntax>() : new[] {
SyntaxFactory.IfStatement(SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, SyntaxFactory.IdentifierName(ItemsName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), CreateThrowException("System.ArgumentNullException"))
}).Concat(prologue).Concat(new[] {
foreachStatement
}).Concat(epilogue)))
.WithStatic(currentMethodIsStatic)
.WithTypeParameterList(currentMethodTypeParameters)
.WithConstraintClauses(currentMethodConstraintClauses)
.NormalizeWhitespace();
methodsToAddToCurrentType.Add(Tuple.Create(currentType, coreFunction));
IEnumerable <ArgumentSyntax> args = new[] { SyntaxFactory.Argument((ExpressionSyntax)Visit(collection)) }.Concat(arguments.Arguments.Skip(1));
if (additionalParameters != null)
{
args = args.Concat(additionalParameters.Select(x => SyntaxFactory.Argument(x.Item2)));
}
var inv = SyntaxFactory.InvocationExpression(GetMethodNameSyntaxWithCurrentTypeParameters(functionName), CreateArguments(args));
currentAggregation = old;
return(inv);
}
public static decimal AggregateCollection(List<int> original, AggregationDelegate myDelegate)
{
return myDelegate(original);
}
public static decimal AggregateCollection(List <int> original, AggregationDelegate aggregation)
{
return(aggregation(original));
}
public int AggregateCollection ( List<int> original , AggregationDelegate aggregate )
{
return aggregate(original);
}
static decimal AggregateCollection(List <int> original, AggregationDelegate aggregate)
{
decimal answer = aggregate(original);
return(answer);
}
