public virtual object GetVariableValue(string variableName)
{
VerifyNotDisposed();
if (variableName == null)
{
throw new ArgumentNullException(
nameof(variableName),
string.Format(Strings.Common_ArgumentIsNull, nameof(variableName))
);
}
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, nameof(variableName)),
nameof(variableName)
);
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new ArgumentException(
string.Format(Strings.Usage_InvalidVariableNameFormat, variableName),
nameof(variableName)
);
}
return(InnerGetVariableValue(variableName));
}
/// <summary>
/// Embeds a host type to script code
/// </summary>
/// <param name="itemName">The name for the new global variable that will represent the type</param>
/// <param name="type">The type to expose</param>
/// <remarks>
/// Host types are exposed to script code in the form of objects whose properties and
/// methods are bound to the type's static members.
/// </remarks>
public void EmbedHostType(string itemName, Type type)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(itemName))
{
throw new ArgumentException(
string.Format(CommonStrings.Common_ArgumentIsEmpty, "itemName"), "itemName");
}
if (!ValidationHelpers.CheckNameFormat(itemName))
{
throw new FormatException(
string.Format(CommonStrings.Runtime_InvalidScriptItemNameFormat, itemName));
}
if (type != null)
{
if (ValidationHelpers.IsPrimitiveType(type) ||
type == typeof(Undefined))
{
throw new NotSupportedTypeException(
string.Format(CommonStrings.Runtime_EmbeddedHostTypeNotSupported, type.FullName));
}
}
else
{
throw new ArgumentNullException("type", string.Format(CommonStrings.Common_ArgumentIsNull, "type"));
}
_jsEngine.EmbedHostType(itemName, type);
}
/// <summary>
/// Sets a value of variable
/// </summary>
/// <param name="variableName">Name of variable</param>
/// <param name="value">Value of variable</param>
/// <exception cref="System.ObjectDisposedException">Operation is performed on a disposed MSIE
/// JavaScript engine.</exception>
/// <exception cref="System.ArgumentException" />
/// <exception cref="System.FormatException">The variable name has incorrect format.</exception>
/// <exception cref="MsieJavaScriptEngine.NotSupportedTypeException">The type of variable value
/// is not supported.</exception>
/// <exception cref="MsieJavaScriptEngine.JsRuntimeException">JavaScript runtime error.</exception>
public void SetVariableValue(string variableName, object value)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(CommonStrings.Common_ArgumentIsEmpty, "variableName"), "variableName");
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new FormatException(
string.Format(CommonStrings.Runtime_InvalidVariableNameFormat, variableName));
}
if (value != null)
{
Type variableType = value.GetType();
if (!ValidationHelpers.IsSupportedType(variableType))
{
throw new NotSupportedTypeException(
string.Format(CommonStrings.Runtime_VariableTypeNotSupported,
variableName, variableType.FullName));
}
}
_jsEngine.SetVariableValue(variableName, value);
}
/// <summary>
/// Gets a value of variable
/// </summary>
/// <typeparam name="T">Type of variable</typeparam>
/// <param name="variableName">Name of variable</param>
/// <returns>Value of variable</returns>
/// <exception cref="System.ObjectDisposedException">Operation is performed on a disposed MSIE
/// JavaScript engine.</exception>
/// <exception cref="System.ArgumentException" />
/// <exception cref="System.FormatException">The variable name has incorrect format.</exception>
/// <exception cref="MsieJavaScriptEngine.NotSupportedTypeException">The type of return value
/// is not supported.</exception>
/// <exception cref="MsieJavaScriptEngine.JsRuntimeException">JavaScript runtime error.</exception>
public T GetVariableValue <T>(string variableName)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(CommonStrings.Common_ArgumentIsEmpty, "variableName"), "variableName");
}
Type returnValueType = typeof(T);
if (!ValidationHelpers.IsSupportedType(returnValueType))
{
throw new NotSupportedTypeException(
string.Format(CommonStrings.Runtime_ReturnValueTypeNotSupported, returnValueType.FullName));
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new FormatException(
string.Format(CommonStrings.Runtime_InvalidVariableNameFormat, variableName));
}
object result = _jsEngine.GetVariableValue(variableName);
return(TypeConverter.ConvertToType <T>(result));
}
public virtual void EmbedHostObject(string itemName, object value)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(itemName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, "itemName"), "itemName");
}
if (!ValidationHelpers.CheckNameFormat(itemName))
{
throw new FormatException(
string.Format(Strings.Runtime_InvalidScriptItemNameFormat, itemName));
}
if (value != null)
{
Type itemType = value.GetType();
if (ValidationHelpers.IsPrimitiveType(itemType) ||
itemType == typeof(Undefined) ||
itemType == typeof(DateTime))
{
throw new NotSupportedTypeException(
string.Format(Strings.Runtime_EmbeddedHostObjectTypeNotSupported, itemType.FullName));
}
}
else
{
throw new ArgumentNullException("value", string.Format(Strings.Common_ArgumentIsNull, "value"));
}
InnerEmbedHostObject(itemName, value);
}
public virtual T GetVariableValue <T>(string variableName)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, "variableName"), "variableName");
}
Type returnValueType = typeof(T);
if (!ValidationHelpers.IsSupportedType(returnValueType))
{
throw new NotSupportedTypeException(
string.Format(Strings.Runtime_ReturnValueTypeNotSupported, returnValueType.FullName));
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new FormatException(
string.Format(Strings.Runtime_InvalidVariableNameFormat, variableName));
}
return(InnerGetVariableValue <T>(variableName));
}
public virtual object CallFunction(string functionName, params object[] args)
{
VerifyNotDisposed();
if (functionName == null)
{
throw new ArgumentNullException(
nameof(functionName),
string.Format(Strings.Common_ArgumentIsNull, nameof(functionName))
);
}
if (string.IsNullOrWhiteSpace(functionName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, nameof(functionName)),
nameof(functionName)
);
}
if (!ValidationHelpers.CheckNameFormat(functionName))
{
throw new ArgumentException(
string.Format(Strings.Usage_InvalidFunctionNameFormat, nameof(functionName)),
nameof(functionName)
);
}
int argumentCount = args.Length;
if (argumentCount > 0)
{
for (int argumentIndex = 0; argumentIndex < argumentCount; argumentIndex++)
{
object argument = args[argumentIndex];
if (argument != null)
{
Type argType = argument.GetType();
if (!ValidationHelpers.IsSupportedType(argType))
{
throw new ArgumentException(
string.Format(Strings.Usage_FunctionParameterTypeNotSupported,
functionName, argType.FullName),
nameof(args)
);
}
}
}
}
return(InnerCallFunction(functionName, args));
}
/// <summary>
/// Calls a function
/// </summary>
/// <typeparam name="T">Type of function result</typeparam>
/// <param name="functionName">Function name</param>
/// <param name="args">Function arguments</param>
/// <returns>Result of the function execution</returns>
/// <exception cref="System.ObjectDisposedException">Operation is performed on a disposed MSIE
/// JavaScript engine.</exception>
/// <exception cref="System.ArgumentException" />
/// <exception cref="System.FormatException">The function name has incorrect format.</exception>
/// <exception cref="MsieJavaScriptEngine.NotSupportedTypeException">The type of return value or
/// one function parameter is not supported.</exception>
/// <exception cref="MsieJavaScriptEngine.JsRuntimeException">JavaScript runtime error.</exception>
public T CallFunction <T>(string functionName, params object[] args)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(functionName))
{
throw new ArgumentException(
string.Format(CommonStrings.Common_ArgumentIsEmpty, "functionName"), "functionName");
}
Type returnValueType = typeof(T);
if (!ValidationHelpers.IsSupportedType(returnValueType))
{
throw new NotSupportedTypeException(
string.Format(CommonStrings.Runtime_ReturnValueTypeNotSupported, returnValueType.FullName));
}
if (!ValidationHelpers.CheckNameFormat(functionName))
{
throw new FormatException(
string.Format(CommonStrings.Runtime_InvalidFunctionNameFormat, functionName));
}
int argumentCount = args.Length;
if (argumentCount > 0)
{
for (int argumentIndex = 0; argumentIndex < argumentCount; argumentIndex++)
{
object argument = args[argumentIndex];
if (argument != null)
{
Type argType = argument.GetType();
if (!ValidationHelpers.IsSupportedType(argType))
{
throw new NotSupportedTypeException(
string.Format(CommonStrings.Runtime_FunctionParameterTypeNotSupported,
functionName, argType.FullName));
}
}
}
}
object result = _jsEngine.CallFunction(functionName, args);
return(TypeConverter.ConvertToType <T>(result));
}
public virtual void EmbedHostType(string itemName, Type type)
{
VerifyNotDisposed();
if (itemName == null)
{
throw new ArgumentNullException(
nameof(itemName),
string.Format(Strings.Common_ArgumentIsNull, nameof(itemName))
);
}
if (type == null)
{
throw new ArgumentNullException(
nameof(type),
string.Format(Strings.Common_ArgumentIsNull, nameof(type))
);
}
if (string.IsNullOrWhiteSpace(itemName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, nameof(itemName)),
nameof(itemName)
);
}
if (!ValidationHelpers.CheckNameFormat(itemName))
{
throw new ArgumentException(
string.Format(Strings.Usage_InvalidScriptItemNameFormat, itemName),
nameof(itemName)
);
}
if (ValidationHelpers.IsPrimitiveType(type) || type == typeof(Undefined))
{
throw new ArgumentException(
string.Format(Strings.Usage_EmbeddedHostTypeNotSupported, type.FullName),
nameof(type)
);
}
InnerEmbedHostType(itemName, type);
}
/// <summary>
/// Removes a variable
/// </summary>
/// <param name="variableName">Name of variable</param>
/// <exception cref="System.ObjectDisposedException">Operation is performed on a disposed MSIE
/// JavaScript engine.</exception>
/// <exception cref="System.ArgumentException" />
/// <exception cref="System.FormatException">The variable name has incorrect format.</exception>
/// <exception cref="MsieJavaScriptEngine.JsRuntimeException">JavaScript runtime error.</exception>
public void RemoveVariable(string variableName)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(CommonStrings.Common_ArgumentIsEmpty, "variableName"), "variableName");
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new FormatException(
string.Format(CommonStrings.Runtime_InvalidVariableNameFormat, variableName));
}
_jsEngine.RemoveVariable(variableName);
}
public virtual object GetVariableValue(string variableName)
{
VerifyNotDisposed();
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, "variableName"), "variableName");
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new FormatException(
string.Format(Strings.Runtime_InvalidVariableNameFormat, variableName));
}
return(InnerGetVariableValue(variableName));
}
public void NameFormatIsWrong()
{
// Arrange
// Act
bool name1FormatIsWrong = ValidationHelpers.CheckNameFormat("good-parts");
bool name2FormatIsWrong = ValidationHelpers.CheckNameFormat("1sale");
bool name3FormatIsWrong = ValidationHelpers.CheckNameFormat("Foo Bar");
bool name4FormatIsWrong = ValidationHelpers.CheckNameFormat("@grid");
bool name5FormatIsWrong = ValidationHelpers.CheckNameFormat("2");
// Assert
Assert.False(name1FormatIsWrong);
Assert.False(name2FormatIsWrong);
Assert.False(name3FormatIsWrong);
Assert.False(name4FormatIsWrong);
Assert.False(name5FormatIsWrong);
}
public void NameFormatIsCorrect()
{
// Arrange
// Act
bool name1FormatIsCorrect = ValidationHelpers.CheckNameFormat("good_parts");
bool name2FormatIsCorrect = ValidationHelpers.CheckNameFormat("i18n");
bool name3FormatIsCorrect = ValidationHelpers.CheckNameFormat("fooBar");
bool name4FormatIsCorrect = ValidationHelpers.CheckNameFormat("$grid");
bool name5FormatIsCorrect = ValidationHelpers.CheckNameFormat("a");
// Assert
Assert.IsTrue(name1FormatIsCorrect);
Assert.IsTrue(name2FormatIsCorrect);
Assert.IsTrue(name3FormatIsCorrect);
Assert.IsTrue(name4FormatIsCorrect);
Assert.IsTrue(name5FormatIsCorrect);
}
public virtual void SetVariableValue(string variableName, object value)
{
VerifyNotDisposed();
if (variableName == null)
{
throw new ArgumentNullException(
nameof(variableName),
string.Format(Strings.Common_ArgumentIsNull, nameof(variableName))
);
}
if (string.IsNullOrWhiteSpace(variableName))
{
throw new ArgumentException(
string.Format(Strings.Common_ArgumentIsEmpty, nameof(variableName)),
nameof(variableName)
);
}
if (!ValidationHelpers.CheckNameFormat(variableName))
{
throw new ArgumentException(
string.Format(Strings.Usage_InvalidVariableNameFormat, variableName),
nameof(variableName)
);
}
if (value != null)
{
Type variableType = value.GetType();
if (!ValidationHelpers.IsSupportedType(variableType))
{
throw new ArgumentException(
string.Format(Strings.Usage_VariableTypeNotSupported,
variableName, variableType.FullName),
nameof(value)
);
}
}
InnerSetVariableValue(variableName, value);
}