internal static CompileResult CompileExpression(
this EvaluationContextBase context,
string expr,
out ResultProperties resultProperties,
out string error,
CompilationTestData testData = null,
DiagnosticFormatter formatter = null
)
{
ImmutableArray <AssemblyIdentity> missingAssemblyIdentities;
var result = context.CompileExpression(
expr,
DkmEvaluationFlags.TreatAsExpression,
ImmutableArray <Alias> .Empty,
formatter ?? DebuggerDiagnosticFormatter.Instance,
out resultProperties,
out error,
out missingAssemblyIdentities,
EnsureEnglishUICulture.PreferredOrNull,
testData
);
Assert.Empty(missingAssemblyIdentities);
return(result);
}
public void SetResultSetProperties(Result command, Result result)
{
int rsProperties = command.RsProperties;
int props = result.RsProperties;
if (rsProperties != props)
{
if (ResultProperties.IsReadOnly(rsProperties))
{
props = ResultProperties.AddHoldable(props, ResultProperties.IsHoldable(rsProperties));
}
else if (ResultProperties.IsUpdatable(props))
{
if (ResultProperties.IsHoldable(rsProperties))
{
this._session.AddWarning(Error.GetError(0x1269));
}
}
else
{
props = ResultProperties.AddHoldable(props, ResultProperties.IsHoldable(rsProperties));
this._session.AddWarning(Error.GetError(0x1268));
}
if (ResultProperties.IsSensitive(rsProperties))
{
this._session.AddWarning(Error.GetError(0x1267));
}
props = ResultProperties.AddScrollable(props, ResultProperties.IsScrollable(rsProperties));
result.RsProperties = props;
}
}
internal CompilationTestData Evaluate(
string source,
OutputKind outputKind,
string methodName,
string expr,
out ResultProperties resultProperties,
out string error,
int atLineNumber = -1,
InspectionContext inspectionContext = null,
bool includeSymbols = true)
{
var compilation0 = CreateCompilationWithMscorlib(
source,
options: (outputKind == OutputKind.DynamicallyLinkedLibrary) ? TestOptions.DebugDll : TestOptions.DebugExe);
var runtime = CreateRuntimeInstance(compilation0, includeSymbols);
var context = CreateMethodContext(runtime, methodName, atLineNumber);
var testData = new CompilationTestData();
ImmutableArray <AssemblyIdentity> missingAssemblyIdentities;
var result = context.CompileExpression(
inspectionContext ?? DefaultInspectionContext.Instance,
expr,
DkmEvaluationFlags.TreatAsExpression,
DiagnosticFormatter.Instance,
out resultProperties,
out error,
out missingAssemblyIdentities,
EnsureEnglishUICulture.PreferredOrNull,
testData);
Assert.Empty(missingAssemblyIdentities);
return(testData);
}
internal CompilationTestData Evaluate(
CSharpCompilation compilation,
string methodName,
string expr,
out ResultProperties resultProperties,
out string error,
int atLineNumber = -1,
bool includeSymbols = true)
{
var runtime = CreateRuntimeInstance(compilation, debugFormat: includeSymbols ? DebugInformationFormat.Pdb : 0);
var context = CreateMethodContext(runtime, methodName, atLineNumber);
var testData = new CompilationTestData();
ImmutableArray <AssemblyIdentity> missingAssemblyIdentities;
var result = context.CompileExpression(
expr,
DkmEvaluationFlags.TreatAsExpression,
NoAliases,
DebuggerDiagnosticFormatter.Instance,
out resultProperties,
out error,
out missingAssemblyIdentities,
EnsureEnglishUICulture.PreferredOrNull,
testData);
Assert.Empty(missingAssemblyIdentities);
return(testData);
}
internal static CompileResult CompileExpression(
this EvaluationContextBase evaluationContext,
string expr,
DkmEvaluationFlags compilationFlags,
ImmutableArray <Alias> aliases,
DiagnosticFormatter formatter,
out ResultProperties resultProperties,
out string error,
out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities,
CultureInfo preferredUICulture,
CompilationTestData testData)
{
var diagnostics = DiagnosticBag.GetInstance();
var result = evaluationContext.CompileExpression(expr, compilationFlags, aliases, diagnostics, out resultProperties, testData);
if (diagnostics.HasAnyErrors())
{
bool useReferencedModulesOnly;
error = evaluationContext.GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, EvaluationContextBase.SystemCoreIdentity, out useReferencedModulesOnly, out missingAssemblyIdentities);
}
else
{
error = null;
missingAssemblyIdentities = ImmutableArray <AssemblyIdentity> .Empty;
}
diagnostics.Free();
return(result);
}
internal override CompileResult CompileExpression(
string expr,
DkmEvaluationFlags compilationFlags,
ImmutableArray <Alias> aliases,
DiagnosticBag diagnostics,
out ResultProperties resultProperties,
Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData)
{
ReadOnlyCollection <string> formatSpecifiers;
var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers);
if (syntax == null)
{
resultProperties = default(ResultProperties);
return(null);
}
var context = this.CreateCompilationContext();
var moduleBuilder = context.CompileExpression(syntax, TypeName, MethodName, aliases, testData, diagnostics, out var synthesizedMethod);
if (moduleBuilder == null)
{
resultProperties = default(ResultProperties);
return(null);
}
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
context.MessageProvider,
() => stream,
getPortablePdbStreamOpt: null,
nativePdbWriterOpt: null,
pdbPathOpt: null,
metadataOnly: false,
isDeterministic: false,
emitTestCoverageData: false,
privateKeyOpt: null,
cancellationToken: default(CancellationToken));
if (diagnostics.HasAnyErrors())
{
resultProperties = default(ResultProperties);
return(null);
}
Debug.Assert(synthesizedMethod.ContainingType.MetadataName == TypeName);
Debug.Assert(synthesizedMethod.MetadataName == MethodName);
resultProperties = synthesizedMethod.ResultProperties;
return(new CSharpCompileResult(
stream.ToArray(),
synthesizedMethod,
formatSpecifiers: formatSpecifiers));
}
}
public HealthCheckData AddProperty(string name, string value)
{
if (Properties == null)
{
Properties = new ResultProperties();
}
Properties.Add(name, value);
return(this);
}
internal override CompileResult CompileAssignment(
string target,
string expr,
ImmutableArray <Alias> aliases,
DiagnosticBag diagnostics,
out ResultProperties resultProperties,
Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData)
{
var assignment = target.ParseAssignment(expr, diagnostics);
if (assignment == null)
{
resultProperties = default(ResultProperties);
return(null);
}
var context = this.CreateCompilationContext();
var moduleBuilder = context.CompileAssignment(assignment, TypeName, MethodName, aliases, testData, diagnostics, out var synthesizedMethod);
if (moduleBuilder == null)
{
resultProperties = default(ResultProperties);
return(null);
}
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
new EmitContext(moduleBuilder, null, diagnostics),
context.MessageProvider,
() => stream,
getPortablePdbStreamOpt: null,
nativePdbWriterOpt: null,
pdbPathOpt: null,
allowMissingMethodBodies: false,
isDeterministic: false,
cancellationToken: default(CancellationToken));
if (diagnostics.HasAnyErrors())
{
resultProperties = default(ResultProperties);
return(null);
}
Debug.Assert(synthesizedMethod.ContainingType.MetadataName == TypeName);
Debug.Assert(synthesizedMethod.MetadataName == MethodName);
resultProperties = synthesizedMethod.ResultProperties;
return(new CSharpCompileResult(
stream.ToArray(),
synthesizedMethod,
formatSpecifiers: null));
}
}
internal override CompileResult CompileExpression(
string expr,
DkmEvaluationFlags compilationFlags,
ImmutableArray <Alias> aliases,
DiagnosticBag diagnostics,
out ResultProperties resultProperties,
Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData)
{
ReadOnlyCollection <string> formatSpecifiers;
var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers);
if (syntax == null)
{
resultProperties = default(ResultProperties);
return(null);
}
var context = this.CreateCompilationContext(syntax);
ResultProperties properties;
var moduleBuilder = context.CompileExpression(TypeName, MethodName, aliases, testData, diagnostics, out properties);
if (moduleBuilder == null)
{
resultProperties = default(ResultProperties);
return(null);
}
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics),
context.MessageProvider,
() => stream,
getPortablePdbStreamOpt: null,
nativePdbWriterOpt: null,
pdbPathOpt: null,
allowMissingMethodBodies: false,
deterministic: false,
cancellationToken: default(CancellationToken));
if (diagnostics.HasAnyErrors())
{
resultProperties = default(ResultProperties);
return(null);
}
resultProperties = properties;
return(new CSharpCompileResult(
stream.ToArray(),
GetSynthesizedMethod(moduleBuilder),
formatSpecifiers: formatSpecifiers));
}
}
internal override CompileResult CompileAssignment(
InspectionContext inspectionContext,
string target,
string expr,
DiagnosticBag diagnostics,
out ResultProperties resultProperties,
Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData)
{
var assignment = target.ParseAssignment(expr, diagnostics);
if (assignment == null)
{
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
var context = this.CreateCompilationContext(assignment);
ResultProperties properties;
var moduleBuilder = context.CompileAssignment(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties);
if (moduleBuilder == null)
{
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics),
context.MessageProvider,
() => stream,
nativePdbWriterOpt: null,
pdbPathOpt: null,
allowMissingMethodBodies: false,
deterministic: false,
cancellationToken: default(CancellationToken));
if (diagnostics.HasAnyErrors())
{
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
resultProperties = properties;
return(new CompileResult(
stream.ToArray(),
typeName: TypeName,
methodName: MethodName,
formatSpecifiers: null));
}
}
internal CompilationTestData Evaluate(
string source,
OutputKind outputKind,
string methodName,
string expr,
out ResultProperties resultProperties,
out string error,
int atLineNumber = -1,
bool includeSymbols = true)
{
var compilation = CreateStandardCompilation(
source,
options: (outputKind == OutputKind.DynamicallyLinkedLibrary) ? TestOptions.DebugDll : TestOptions.DebugExe);
return(Evaluate(compilation, methodName, expr, out resultProperties, out error, atLineNumber, includeSymbols));
}
public void CloseAllTransactionNavigators()
{
if (this._resultMap != null)
{
List <long> list = new List <long>();
foreach (KeyValuePair <long, Result> pair in this._resultMap)
{
Result result = pair.Value;
if (!ResultProperties.IsHoldable(result.RsProperties))
{
result.GetNavigator().Close();
list.Add(pair.Key);
}
}
foreach (long num in list)
{
this._resultMap.Remove(num);
}
}
}
void CalculateOptionPrice()
{
//FIXME: This entire function
OptionType optionType = OptionType.AmericanOptionType;
BinomialStrategyType binomialStrategyType = BinomialStrategyType.CRRBinomialStrategyType; int numberSteps = 200; double interestRate = 0.1;
double volatility = 0.1; double strike = 200; double expiry = 1.0; double currentPrice = 200; double costOfCarry = 0.1; bool isCall = true;
foreach (Property property in InputProperties)
{
if (property.Key is string)
{
string key = property.Key as string;
if (key == InputKeyConstants.OptionType)
{
optionType = ((property.Value as Selection).SelectedItem == "American Option") ? OptionType.AmericanOptionType : OptionType.EuropeanOptionType;
}
else if (key == InputKeyConstants.BinomialType)
{
binomialStrategyType = BinomialStrategyType.CRRBinomialStrategyType;
}
else if (key == InputKeyConstants.NumberOfSteps)
{
numberSteps = int.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.InterestRate)
{
interestRate = double.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.Volatility)
{
volatility = double.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.Strike)
{
strike = double.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.Expiry)
{
expiry = double.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.CurrentPrice)
{
currentPrice = double.Parse(property.Value.ToString());
}
else if (key == InputKeyConstants.IsCall)
{
isCall = true;//FIXME
}
}
}
VegaCLR clr = new VegaCLR();
double price = 0.0;
double delta = 0.0;
double vega = 0.0;
clr.CalculateOption(optionType, binomialStrategyType, numberSteps, interestRate, volatility, strike, expiry, currentPrice, costOfCarry, isCall, ref price, ref delta, ref vega);
foreach (Property property in ResultProperties)
{
if (property.Key == ResultKeyConstants.Price)
{
property.Value = price;
}
else if (property.Key == ResultKeyConstants.Delta)
{
property.Value = delta;
}
else if (property.Key == ResultKeyConstants.Vega)
{
property.Value = vega;
}
}
ResultProperties.Add(new Property("", ""));
ResultProperties.Remove(ResultProperties.Last()); //FIXME
_plotViewModel.GraphData = clr.PriceData;
}
internal override CompileResult CompileAssignment(
InspectionContext inspectionContext,
string target,
string expr,
DiagnosticFormatter formatter,
out ResultProperties resultProperties,
out string error,
out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities,
System.Globalization.CultureInfo preferredUICulture,
Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData)
{
var diagnostics = DiagnosticBag.GetInstance();
try
{
var assignment = target.ParseAssignment(expr, diagnostics);
if (assignment == null)
{
error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities);
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
var context = this.CreateCompilationContext(assignment);
ResultProperties properties;
var moduleBuilder = context.CompileAssignment(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties);
if (moduleBuilder == null)
{
error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities);
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics),
context.MessageProvider,
stream,
nativePdbWriterOpt: null,
allowMissingMethodBodies: false,
deterministic: false,
cancellationToken: default(CancellationToken));
if (diagnostics.HasAnyErrors())
{
error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities);
resultProperties = default(ResultProperties);
return(default(CompileResult));
}
resultProperties = properties;
error = null;
missingAssemblyIdentities = ImmutableArray <AssemblyIdentity> .Empty;
return(new CompileResult(
stream.ToArray(),
typeName: TypeName,
methodName: MethodName,
formatSpecifiers: null));
}
}
finally
{
diagnostics.Free();
}
}
protected virtual HealthCheckData DoTest()
{
// check it even exists!
var count = 0;
DateTime?oldestMessageDated = null;
var exists = MessageQueue.Exists(myConfig.QueueName);
string info;
if (exists)
{
var queue = new MessageQueue(myConfig.QueueName)
{
MessageReadPropertyFilter = new MessagePropertyFilter
{
ArrivedTime = true
}
};
var me = queue.GetMessageEnumerator2();
var timeout = new TimeSpan(0, 0, 0);
while (me.MoveNext(timeout))
{
var msg = me.Current;
if (!oldestMessageDated.HasValue)
{
oldestMessageDated = msg.ArrivedTime;
}
else if (msg.ArrivedTime < oldestMessageDated)
{
oldestMessageDated = msg.ArrivedTime;
}
count++;
}
info = string.Format("Queue {0} has {1} messages", myConfig.QueueName, count);
}
else
{
info = string.Format("Queue {0} does not exist!", myConfig.QueueName);
}
var props = new ResultProperties
{
{ "Queue", myConfig.QueueName },
{ "Count", count.ToString() }
};
if (oldestMessageDated.HasValue)
{
props.Add("Oldest", oldestMessageDated.ToString());
}
var result = new HealthCheckData
{
Identity = Identity,
Info = info,
Result = exists,
Properties = props
};
if (exists)
{
result.ResultCount = count;
}
return(result);
}
public static string GetImageName(this ResultProperties resultProperties)
{
switch (resultProperties.Category)
{
case DkmEvaluationResultCategory.Other:
case DkmEvaluationResultCategory.Data:
if ((resultProperties.ModifierFlags & DkmEvaluationResultTypeModifierFlags.Constant) != 0)
{
goto case DkmEvaluationResultCategory.Field;
}
return(PredefinedDbgValueNodeImageNames.Data);
case DkmEvaluationResultCategory.Method:
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Method);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.MethodPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.MethodPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.MethodFamily);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Method);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.MethodFamily);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Method);
}
case DkmEvaluationResultCategory.Event:
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Event);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.EventPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.EventPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.EventFamily);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Event);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.EventFamily);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Event);
}
case DkmEvaluationResultCategory.Property:
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Property);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.PropertyPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.PropertyPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.PropertyFamily);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Property);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.PropertyFamily);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Property);
}
case DkmEvaluationResultCategory.Field:
if ((resultProperties.ModifierFlags & DkmEvaluationResultTypeModifierFlags.Constant) != 0)
{
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Constant);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.ConstantPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.ConstantPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.ConstantFamily);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Constant);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.ConstantFamily);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Constant);
}
}
else
{
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Field);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.FieldPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.FieldPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.FieldFamily);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Field);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.FieldFamily);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Field);
}
}
case DkmEvaluationResultCategory.Class:
case DkmEvaluationResultCategory.BaseClass:
case DkmEvaluationResultCategory.InnerClass:
case DkmEvaluationResultCategory.MostDerivedClass:
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Class);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.ClassPublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.ClassPrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.ClassProtected);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Class);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.ClassInternal);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Class);
}
case DkmEvaluationResultCategory.Interface:
switch (resultProperties.AccessType)
{
case DkmEvaluationResultAccessType.None:
return(PredefinedDbgValueNodeImageNames.Interface);
case DkmEvaluationResultAccessType.Public:
return(PredefinedDbgValueNodeImageNames.InterfacePublic);
case DkmEvaluationResultAccessType.Private:
return(PredefinedDbgValueNodeImageNames.InterfacePrivate);
case DkmEvaluationResultAccessType.Protected:
return(PredefinedDbgValueNodeImageNames.InterfaceProtected);
case DkmEvaluationResultAccessType.Final:
return(PredefinedDbgValueNodeImageNames.Interface);
case DkmEvaluationResultAccessType.Internal:
return(PredefinedDbgValueNodeImageNames.InterfaceInternal);
default:
Debug.Fail($"Unknown access type: {resultProperties.AccessType}");
return(PredefinedDbgValueNodeImageNames.Interface);
}
case DkmEvaluationResultCategory.Local:
return(PredefinedDbgValueNodeImageNames.Local);
case DkmEvaluationResultCategory.Parameter:
return(PredefinedDbgValueNodeImageNames.Parameter);
default:
Debug.Fail($"Unknown category: {resultProperties.Category}");
return(PredefinedDbgValueNodeImageNames.Data);
}
}
public Result GetDataResultHead(Result command, Result result, bool isNetwork)
{
int fetchSize = command.GetFetchSize();
result.SetResultId(this._session.ActionTimestamp);
int rsProperties = command.RsProperties;
int props = result.RsProperties;
if (rsProperties != props)
{
if (ResultProperties.IsReadOnly(rsProperties))
{
props = ResultProperties.AddHoldable(props, ResultProperties.IsHoldable(rsProperties));
}
else if (ResultProperties.IsReadOnly(props))
{
props = ResultProperties.AddHoldable(props, ResultProperties.IsHoldable(rsProperties));
}
else if (this._session.IsAutoCommit())
{
props = ResultProperties.AddHoldable(props, ResultProperties.IsHoldable(rsProperties));
}
else
{
props = ResultProperties.AddHoldable(props, false);
}
props = ResultProperties.AddScrollable(props, ResultProperties.IsScrollable(rsProperties));
result.RsProperties = props;
}
bool flag = false;
bool flag2 = false;
if (ResultProperties.IsUpdatable(result.RsProperties) || ResultProperties.IsHoldable(result.RsProperties))
{
flag = true;
}
if (isNetwork)
{
if ((fetchSize != 0) && (result.GetNavigator().GetSize() > fetchSize))
{
flag2 = true;
flag = true;
}
}
else if (!result.GetNavigator().IsMemory())
{
flag = true;
}
if (flag)
{
if (this._resultMap == null)
{
this._resultMap = new Dictionary <long, Result>();
}
this._resultMap.Add(result.GetResultId(), result);
}
if (flag2)
{
result = Result.NewDataHeadResult(this._session, result, 0, fetchSize);
}
return(result);
}
public LmiDataRowReader(LmiHandler lmiHandler)
{
this.lmiHandler = lmiHandler;
initQuery();
resultProperties = new ResultProperties();
resultProperties.SetProperty("Host", lmiHandler.Host);
resultProperties.SetProperty("UserName", lmiHandler.UserName);
resultProperties.SetProperty("Query", lmiHandler.Query);
if (lmiHandler.QueryId != null)
{
resultProperties.SetProperty("QueryID", lmiHandler.QueryId);
}
if (lmiHandler.IsCorrelation)
{
resultProperties.SetProperty("Correlation", "true");
}
else
{
resultProperties.SetProperty("Correlation", "false");
}
columns = new DataRowReaderColumn[queryDesc.columns.Length];
cursors = new DataValueCursor[queryDesc.columns.Length];
int i = 0;
foreach (ColumnDesc column in queryDesc.columns)
{
switch (column.type)
{
case "TIMESTAMP":
cursors[i] = DataValueCursor.CreateMutableCursor(DataType.DateTime);
columns[i] = new DataRowReaderColumn(column.name, DataType.DateTime, cursors[i]);
break;
case "INT":
cursors[i] = DataValueCursor.CreateMutableCursor(DataType.Integer);
columns[i] = new DataRowReaderColumn(column.name, DataType.Integer, cursors[i]);
break;
case "LONG":
cursors[i] = DataValueCursor.CreateMutableCursor(DataType.LongInteger);
columns[i] = new DataRowReaderColumn(column.name, DataType.LongInteger, cursors[i]);
break;
case "DOUBLE":
cursors[i] = DataValueCursor.CreateMutableCursor(DataType.Real);
columns[i] = new DataRowReaderColumn(column.name, DataType.Real, cursors[i]);
break;
case "BOOLEAN":
cursors[i] = DataValueCursor.CreateMutableCursor(DataType.Boolean);
columns[i] = new DataRowReaderColumn(column.name, DataType.Boolean, cursors[i]);
break;
//case "INET_ADDR":
default:
cursors[i] = (MutableValueCursor <string>)DataValueCursor.CreateMutableCursor(DataType.String);
columns[i] = new DataRowReaderColumn(column.name, DataType.String, cursors[i]);
break;
}
i++;
}
}
