public AssemblyDataGenerator()
{
var docUtility = new DataGeneratorUtility(new NameGenerator());
var idGen = new CommentIDGenerator();
var typeUtility = new TypeDataUtility(docUtility);
var methodUtility = new MethodBaseUtility(docUtility, idGen);
methodGen = new MethodDataGenerator(docUtility, methodUtility);
classGen = new ClassDataGenerator(docUtility, typeUtility, idGen);
enumGen = new EnumDataGenerator(docUtility, typeUtility, idGen);
eventGen = new EventDataGenerator(docUtility, methodUtility, idGen);
fieldGen = new FieldDataGenerator(docUtility, idGen);
propertyGen = new PropertyDataGenerator(docUtility, methodUtility, idGen);
ctorGen = new ConstructorDataGenerator(methodUtility);
operatorGen = new OperatorDataGenerator(methodGen);
}
public AssemblyDataGenerator(
IClassDataGenerator classGen,
IEnumDataGenerator enumGen,
IEventDataGenerator eventGen,
IFieldDataGenerator fieldGen,
IPropertyDataGenerator propertyGen,
IConstructorDataGenerator ctorGen,
IOperatorDataGenerator operatorGen,
IMethodDataGenerator methodGen
)
{
Check.Ref(classGen, enumGen, eventGen, fieldGen, propertyGen, ctorGen, operatorGen, methodGen);
this.classGen = classGen;
this.enumGen = enumGen;
this.eventGen = eventGen;
this.fieldGen = fieldGen;
this.propertyGen = propertyGen;
this.ctorGen = ctorGen;
this.operatorGen = operatorGen;
this.methodGen = methodGen;
}
private async void btnStart_Click(object sender, EventArgs e)
{
try
{
if (btnStart.Text == StopCaption)
{
await CancelActions();
btnStart.Text = StartCaption;
return;
}
if (serviceBusHelper != null &&
ValidateParameters())
{
if (startLog != null)
{
startLog();
}
btnStart.Enabled = false;
Cursor.Current = Cursors.WaitCursor;
//*****************************************************************************************************
// Initialize Statistics and Manager Action
//*****************************************************************************************************
actionCount = 0;
senderMessageNumber = 0;
senderMessagesPerSecond = 0;
senderMinimumTime = long.MaxValue;
senderMaximumTime = 0;
senderAverageTime = 0;
senderTotalTime = 0;
lblSenderLastTime.Text = string.Empty;
lblSenderAverageTime.Text = string.Empty;
lblSenderMaximumTime.Text = string.Empty;
lblSenderMinimumTime.Text = string.Empty;
lblSenderMessagesPerSecond.Text = string.Empty;
lblSenderMessageNumber.Text = string.Empty;
if (checkBoxSenderEnableGraph.Checked)
{
chart.Series.ToList().ForEach(s => s.Points.Clear());
}
managerResetEvent = new ManualResetEventSlim(false);
Action<CancellationTokenSource> managerAction = cts =>
{
if (cts == null)
{
return;
}
try
{
managerResetEvent.Wait(cts.Token);
}
catch (OperationCanceledException)
{
}
if (!cts.IsCancellationRequested)
{
Invoke((MethodInvoker) delegate { btnStart.Text = StartCaption; });
}
};
Action updateGraphAction = () =>
{
var ok = true;
long max = 10;
while (!graphCancellationTokenSource.IsCancellationRequested && (actionCount > 1 || ok))
{
ok = true;
long sendMessageNumber = 0;
long sendTotalTime = 0;
while (ok && sendMessageNumber < max)
{
Tuple<long, long, DirectionType> tuple;
ok = blockingCollection.TryTake(out tuple, 10);
if (ok)
{
sendMessageNumber += tuple.Item1;
sendTotalTime += tuple.Item2;
if (sendMessageNumber > max)
{
max = sendMessageNumber;
}
}
}
if (sendMessageNumber > 0)
{
var sendTuple = new Tuple<long, long, DirectionType>(sendMessageNumber, sendTotalTime, DirectionType.Send);
if (InvokeRequired)
{
Invoke(new UpdateStatisticsDelegate(InternalUpdateStatistics),
new object[]
{
sendTuple.Item1,
sendTuple.Item2,
sendTuple.Item3
});
}
else
{
InternalUpdateStatistics(sendTuple.Item1,
sendTuple.Item2,
sendTuple.Item3);
}
}
}
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
};
AsyncCallback updateGraphCallback = a =>
{
var action = a.AsyncState as Action;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
blockingCollection = new BlockingCollection<Tuple<long, long, DirectionType>>();
//*****************************************************************************************************
// Sending messages to a EventHub
//*****************************************************************************************************
if (eventDataCount > 0)
{
// Create event hub clients. They are cached for later usage to improve performance.
if (isSenderFaulted ||
eventHubClientCollection == null ||
eventHubClientCollection.Count == 0 ||
eventHubClientCollection.Count < senderTaskCount)
{
eventHubClientCollection = new List<EventHubClient>(senderTaskCount);
var amqpConnectionString = GetAmqpConnectionString(serviceBusHelper.ConnectionString);
for (var i = 0; i < senderTaskCount; i++)
{
eventHubClientCollection.Add(EventHubClient.CreateFromConnectionString(amqpConnectionString, eventHubDescription.Path));
}
isSenderFaulted = false;
}
// Create outbound message template list
var eventDataTemplateList = new List<EventData>();
var updatePartitionKey = checkBoxUpdatePartitionKey.Checked;
var noPartitionKey = checkBoxNoPartitionKey.Checked;
if (messageTabControl.SelectedIndex == MessageTabPage)
{
eventDataTemplateList.Add(serviceBusHelper.CreateEventDataTemplate(txtMessageText.Text,
GetPartitionKey(),
bindingSource.Cast<MessagePropertyInfo>()));
}
else if (messageTabControl.SelectedIndex == FilesTabPage)
{
updatePartitionKey = !radioButtonJsonTemplate.Checked && !radioButtonXmlTemplate.Checked &&
checkBoxUpdatePartitionKey.Checked;
var fileList = messageFileListView.Items.Cast<ListViewItem>()
.Where(i => i.Checked)
.Select(i => i.Text)
.ToList();
if (fileList.Count == 0)
{
writeToLog(NoMessageSelected);
return;
}
foreach (var fileName in fileList)
{
try
{
using (var streamReader = new StreamReader(fileName))
{
var text = streamReader.ReadToEnd();
EventData template;
if (radioButtonBinaryFile.Checked)
{
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
using (var binaryReader = new BinaryReader(fileStream))
{
var bytes = binaryReader.ReadBytes((int) fileStream.Length);
template = serviceBusHelper.CreateEventDataTemplate(new MemoryStream(bytes),
GetPartitionKey(),
bindingSource.Cast<MessagePropertyInfo>());
}
}
}
else
{
if (radioButtonTextFile.Checked)
{
template = serviceBusHelper.CreateEventDataTemplate(text, GetPartitionKey(), bindingSource.Cast<MessagePropertyInfo>());
}
else if (radioButtonJsonTemplate.Checked)
{
try
{
var eventDataTemplate = JsonSerializerHelper.Deserialize<EventDataTemplate>(text);
template = serviceBusHelper.CreateEventDataTemplate(eventDataTemplate);
}
catch (Exception)
{
writeToLog(string.Format(InvalidJsonTemplate, fileName));
template = serviceBusHelper.CreateEventDataTemplate(text, GetPartitionKey(), bindingSource.Cast<MessagePropertyInfo>());
}
}
else // XML Template
{
try
{
var eventDataTemplate = XmlSerializerHelper.Deserialize<EventDataTemplate>(text);
template = serviceBusHelper.CreateEventDataTemplate(eventDataTemplate);
}
catch (Exception)
{
writeToLog(string.Format(InvalidXmlTemplate, fileName));
template = serviceBusHelper.CreateEventDataTemplate(text, GetPartitionKey(), bindingSource.Cast<MessagePropertyInfo>());
}
}
}
if (template != null)
{
eventDataTemplateList.Add(template);
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
}
else // Event Data Generator Tab
{
try
{
senderEventDataGenerator = eventDataGeneratorPropertyGrid.SelectedObject as IEventDataGenerator;
if (senderEventDataGenerator != null)
{
eventDataTemplateList = new List<EventData>(senderEventDataGenerator.GenerateEventDataCollection(txtMessageCount.IntegerValue, writeToLog));
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
try
{
senderCancellationTokenSource = new CancellationTokenSource();
currentIndex = 0;
senderEventDataInspector = cboSenderInspector.SelectedIndex > 0
? Activator.CreateInstance(serviceBusHelper.EventDataInspectors[cboSenderInspector.Text]) as IEventDataInspector
: null;
Func<long> getMessageNumber = () =>
{
lock (this)
{
return currentIndex++;
}
};
Action<int, IEnumerable<EventData>> senderAction =
(taskId, messageTemplateEnumerable) =>
{
try
{
var traceMessage = serviceBusHelper.SendEventData(eventHubClientCollection[taskId],
messageTemplateEnumerable,
getMessageNumber,
eventDataCount,
taskId,
updatePartitionKey,
noPartitionKey,
checkBoxAddMessageNumber.Checked,
checkBoxEnableSenderLogging.Checked,
checkBoxSenderVerboseLogging.Checked,
checkBoxSenderEnableStatistics.Checked,
checkBoxSendBatch.Checked,
senderBatchSize,
checkBoxSenderThinkTime.Checked,
senderThinkTime,
senderEventDataInspector,
UpdateStatistics,
senderCancellationTokenSource,
partitionDescription != null ?
partitionDescription.PartitionId :
null).Result;
if (!string.IsNullOrWhiteSpace(traceMessage))
{
writeToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
catch (Exception ex)
{
isSenderFaulted = true;
HandleException(ex);
}
};
// Define Sender AsyncCallback
AsyncCallback senderCallback = a =>
{
var action = a.AsyncState as Action<int, IEnumerable<EventData>>;
if (action != null)
{
action.EndInvoke(a);
if (Interlocked.Decrement(ref actionCount) == 0)
{
managerResetEvent.Set();
}
}
};
// Start Sender Actions
for (var i = 0; i < Math.Min(eventDataCount, senderTaskCount); i++)
{
senderAction.BeginInvoke(i, eventDataTemplateList, senderCallback, senderAction);
Interlocked.Increment(ref actionCount);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
if (actionCount > 0)
{
managerCancellationTokenSource = new CancellationTokenSource();
managerAction.BeginInvoke(managerCancellationTokenSource, null, null);
graphCancellationTokenSource = new CancellationTokenSource();
updateGraphAction.BeginInvoke(updateGraphCallback, updateGraphAction);
Interlocked.Increment(ref actionCount);
btnStart.Text = StopCaption;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
finally
{
btnStart.Enabled = true;
Cursor.Current = Cursors.Default;
}
}
