public void CreateCommand_WithParameters()
{
var db = NewSqlHelper();
var commandText = "text {0}, {1}, {2}, {3}";
var p0 = 1;
var p1 = "foo";
var p2 = DateTime.Now;
var p3 = new RawValue("(raw text)");
var command = db.CreateCommand(commandText, p0, p1, p2, p3);
Assert.AreEqual("text @p0, @p1, @p2, (raw text)", command.CommandText);
Assert.AreEqual(CommandType.Text, command.CommandType);
Assert.AreEqual(3, command.Parameters.Count);
Assert.AreEqual(p0, command.Parameters[0].Value);
Assert.AreEqual(p1, command.Parameters[1].Value);
Assert.AreEqual(p2, command.Parameters[2].Value);
}
} //改名分类也可以category
public override string ToString()
{
return(RawValue.ToString());
}
public bool Remove(string key)
{
return(RawValue.Remove(key));
}
public override int GetHashCode() {
return RawValue.GetHashCode();
}
public override int GetHashCode() => RawValue.GetHashCode();
private void FormatValue()
{
FormattedValue = Formatter.Format(RawValue.ToString());
}
public override void WriteTo(IOutputStream stream, File context)
{
stream.Write(RawValue.ToString(context.Configuration.RealFormat, formatInfo));
}
public override string ToString()
{
string raw = null;
if (Engine != null)
{
var e = this.Contains("convert_string").FirstOrDefault();
if (e != null)
{
var scopes = new ValueContainer(Engine);
scopes.Push(Engine.Globals);
scopes.NewStackBoundary();
dynamic ss = new Value();
ss.@this = this;
scopes.Push(ss);
dynamic scopeValue
= new Value(scopes, Engine.GlobalContainer.FindValue("Scopes"));
var expression = ((FunctionAbstract)e.RawValue).Lambda;
var c = new FunctionCallExpression(expression, new List <Value>()
{
(Value)scopeValue
});
dynamic res = Engine.RunExpressionCustomScope(c, scopes);
return((string)res);
}
}
if (IsNumber)
{
raw = RawValue.ToString();
}
if (RawValue is string)
{
raw = $"\"{RawValue}\"";
}
if (RawValue is Expression)
{
raw = ((Expression)RawValue).ToString();
}
if (IsBool)
{
raw = $"{RawValue}";
}
if (RawValue is FunctionAbstract)
{
raw = ((FunctionAbstract)RawValue).ToString();
return(raw);
}
if (RawValue is Delegate)
{
raw = ((Delegate)RawValue).ToString();
}
if (IsArray)
{
var v = (List <Value>)RawValue;
raw = "[" + string.Join(",", v.Select(x => x.ToString())) + "]";
}
var left = raw;
var right = (Values?.Any() ?? false) ? $"({string.Join(",", Values.Keys)})" : null;
if (left != null && right != null)
{
return($"{left}: {right}");
}
if (left != null)
{
return(left);
}
if (right != null)
{
return(right);
}
if (RawValue.ToString() != RawValue.GetType().ToString())
{
return(RawValue.ToString());
}
return("null");
}
IEnumerator IEnumerable.GetEnumerator()
{
return(RawValue.GetEnumerator());
}
public IEnumerator <KeyValuePair <string, BsonValue> > GetEnumerator()
{
return(RawValue.GetEnumerator());
}
public bool Remove(KeyValuePair <string, BsonValue> item)
{
return(RawValue.Remove(item.Key));
}
public bool Contains(KeyValuePair <string, BsonValue> item)
{
return(RawValue.Contains(item));
}
public void Clear()
{
RawValue.Clear();
}
public bool TryGetValue(string key, out BsonValue value)
{
return(RawValue.TryGetValue(key, out value));
}
public Token PopPrefix() =>
new Token(StartLocation, EndLocation, Type, Prefixes.Skip(1).ToList(), Value,
RawValue.Substring(Prefixes[0].Length));
public string ToString(IFormatProvider provider)
{
return(RawValue?.ToString());
}
public override string ToString() => RawValue?.ToString();
public T GenericReturn <T>()
{
if (RawValue is T)
{
return((T)RawValue);
}
if (RawValue is string)
{
return(((string)RawValue).Convert <T>());
}
//Is it a list
if (typeof(T).HasElementType || typeof(IList).IsAssignableFrom(typeof(T)))
{
var subType = typeof(T).GetElementType() ?? typeof(T).GenericTypeArguments.FirstOrDefault();
Array data;
//Convert from RawData to Array
if (RawValue is IList)
{
var vals = (IList)RawValue;
data = Array.CreateInstance(subType, vals.Count);
for (var i = 0; i < vals.Count; i++)
{
var val = (Value)vals[i];
data.SetValue(val.ToType(subType, null), i);
}
}
else
{
throw new NotSupportedException();
}
//Convert from Array to T
if (typeof(T).IsArray)
{
dynamic typedData = Array.CreateInstance(subType, data.Length);
data.CopyTo(typedData, 0);
return(typedData);
}
else if (typeof(IList).IsAssignableFrom(typeof(T)))
{
var listInstance = (IList)typeof(List <>)
.MakeGenericType(subType)
.GetConstructor(Type.EmptyTypes)
?.Invoke(null);
if (listInstance == null)
{
throw new NotSupportedException();
}
var converter = TypeDescriptor.GetConverter(subType);
foreach (var i in data)
{
listInstance.Add(converter.ConvertTo(i, subType));
}
return((T)listInstance);
}
else
{
throw new NotSupportedException();
}
}
try
{
return((T)ToType(typeof(T), null));
}
catch (NotSupportedException)
{
var valo = RawValue?.GetType().Name ?? RawValue?.GetType().Name ?? "null";
throw new InvalidCastException(
$"Cannot convert {valo} to {typeof(T).Name}");
}
catch (NullReferenceException)
{
throw new InvalidCastException(
$"Cannot convert Null to {typeof(T).Name}");
}
}
public override void WriteTo(IOutputStream stream, File context)
{
stream.Write(RawValue.ToString());
}
// this is not the perfect solution,
// as it displays the value always in hex
// which may be inconsistent with monitor
// output mode
public override string ToString()
{
return($"0x{RawValue.ToString("x")}");
}
string IConvertible.ToString(IFormatProvider provider) => RawValue.ToString(provider);
public string ToXml()
{
return(RawValue.ToString());
}
public virtual BsonValue this[int index]
{
get { return(RawValue.ElementAt(index)); }
set { RawValue[index] = value ?? Null; }
}
public byte[] ToByteArray(
)
{
return((byte[])RawValue.Clone());
}
/// <summary>
/// Invokes this cmdlet's action against the current object in the pipeline.
/// </summary>
protected override void PerformSingleOperation()
{
var ids = GetSingleOperationId(Object, Id);
if (IsNormalParameterSet)
ExecuteOperation(() => client.SetObjectProperty(ids, Property, Value), $"Setting object {BasicShouldProcessMessage} setting '{Property}' to {Value.ToQuotedList()}");
else if (IsDynamicParameterSet)
{
var strActions = dynamicParameters.Select(p => $"'{p.Property}' to {p.Value.ToQuotedList()}");
var str = string.Join(", ", strActions);
ExecuteOperation(() => client.SetObjectProperty(ids, dynamicParameters), $"Setting object {BasicShouldProcessMessage} setting {str}");
}
else
{
if (IsRawPropertyParameterSet)
{
var parameter = new CustomParameter(RawProperty, RawValue, ParameterType.MultiParameter);
ExecuteOperation(() => client.SetObjectPropertyRaw(ids, parameter), $"Setting object {BasicShouldProcessMessage} setting '{RawProperty}' to {RawValue.ToQuotedList()}");
}
else
{
var settingsStr = string.Join(", ", parameters.Select(p => $"{p.Name} = {p.Value.ToQuotedList()}"));
ExecuteOperation(() => client.SetObjectPropertyRaw(ids, parameters), $"Setting object {BasicShouldProcessMessage} settings {settingsStr}");
}
}
}
/// <summary>
/// Invokes this cmdlet's action against all queued items from the pipeline.
/// </summary>
/// <param name="ids">The Object IDs of all queued items.</param>
protected override void PerformMultiOperation(int[] ids)
{
if (IsNormalParameterSet)
ExecuteMultiOperation(() => client.SetObjectProperty(ids, Property, Value), $"Setting {GetMultiTypeListSummary()} setting '{Property}' to {Value.ToQuotedList()}");
else if (IsDynamicParameterSet)
{
var strActions = dynamicParameters.Select(p => $"'{p.Property}' to {p.Value.ToQuotedList()}");
var str = string.Join(", ", strActions);
ExecuteMultiOperation(() => client.SetObjectProperty(ids, dynamicParameters), $"Setting {GetMultiTypeListSummary()} setting {str}");
}
else
{
if (IsRawPropertyParameterSet)
{
var parameter = new CustomParameter(RawProperty, RawValue, ParameterType.MultiParameter);
ExecuteMultiOperation(() => client.SetObjectPropertyRaw(ids, parameter), $"Setting {GetMultiTypeListSummary()} setting '{RawProperty}' to {RawValue.ToQuotedList()}");
}
else
{
var settingsStr = string.Join(", ", parameters.Select(p => $"'{p.Name}' = {p.Value.ToQuotedList()}"));
ExecuteMultiOperation(() => client.SetObjectPropertyRaw(ids, parameters.ToArray()), $"Setting {GetMultiTypeListSummary()} settings {settingsStr}");
}
}
}
public bool ContainsKey(string key)
{
return(RawValue.ContainsKey(key));
}
