private static void EncodeAndAddReturnValue(PSObject psObject, object returnValue)
{
if (returnValue != null)
{
RemoteHostEncoder.EncodeAndAddAsProperty(psObject, "mr", returnValue);
}
}
private static PSObject EncodeCollection(IList collection)
{
ArrayList arrayList = new ArrayList();
foreach (object obj in (IEnumerable)collection)
{
arrayList.Add(RemoteHostEncoder.EncodeObject(obj));
}
return(new PSObject((object)arrayList));
}
private static PSObject EncodeParameters(object[] parameters)
{
ArrayList arrayList = new ArrayList();
for (int index = 0; index < parameters.Length; ++index)
{
object obj = parameters[index] == null ? (object)null : RemoteHostEncoder.EncodeObject(parameters[index]);
arrayList.Add(obj);
}
return(new PSObject((object)arrayList));
}
/// <summary>
/// Encode and add return value.
/// </summary>
private static void EncodeAndAddReturnValue(PSObject psObject, object returnValue)
{
// Do nothing if the return value is null.
if (returnValue == null)
{
return;
}
// Otherwise add the property.
RemoteHostEncoder.EncodeAndAddAsProperty(psObject, RemoteDataNameStrings.MethodReturnValue, returnValue);
}
private static PSObject EncodeParameters(object[] parameters)
{
ArrayList list = new ArrayList();
for (int i = 0; i < parameters.Length; i++)
{
object obj2 = (parameters[i] == null) ? null : RemoteHostEncoder.EncodeObject(parameters[i]);
list.Add(obj2);
}
return(new PSObject(list));
}
private static object[] DecodeParameters(PSObject parametersPSObject, Type[] parameterTypes)
{
ArrayList baseObject = (ArrayList)parametersPSObject.BaseObject;
List <object> objectList = new List <object>();
for (int index = 0; index < baseObject.Count; ++index)
{
object obj = baseObject[index] == null ? (object)null : RemoteHostEncoder.DecodeObject(baseObject[index], parameterTypes[index]);
objectList.Add(obj);
}
return(objectList.ToArray());
}
private static IList DecodeCollection(PSObject psObject, Type collectionType)
{
Type genericArgument = collectionType.GetGenericArguments()[0];
ArrayList baseObject = RemoteHostEncoder.SafelyGetBaseObject <ArrayList>(psObject);
IList instance = (IList)Activator.CreateInstance(collectionType);
foreach (object obj in baseObject)
{
instance.Add(RemoteHostEncoder.DecodeObject(obj, genericArgument));
}
return(instance);
}
private static object[] DecodeParameters(PSObject parametersPSObject, Type[] parameterTypes)
{
ArrayList baseObject = (ArrayList)parametersPSObject.BaseObject;
List <object> list2 = new List <object>();
for (int i = 0; i < baseObject.Count; i++)
{
object item = (baseObject[i] == null) ? null : RemoteHostEncoder.DecodeObject(baseObject[i], parameterTypes[i]);
list2.Add(item);
}
return(list2.ToArray());
}
/// <summary>
/// Encode parameters.
/// </summary>
private static PSObject EncodeParameters(object[] parameters)
{
// Encode the parameters and wrap the array into an ArrayList and then into a PSObject.
ArrayList parameterList = new ArrayList();
for (int i = 0; i < parameters.Length; ++i)
{
object parameter = parameters[i] == null ? null : RemoteHostEncoder.EncodeObject(parameters[i]);
parameterList.Add(parameter);
}
return(new PSObject(parameterList));
}
private static Exception DecodeException(PSObject psObject)
{
object obj2 = RemoteHostEncoder.DecodePropertyValue(psObject, "me", typeof(Exception));
if (obj2 == null)
{
return(null);
}
if (!(obj2 is Exception))
{
throw RemoteHostExceptions.NewDecodingFailedException();
}
return((Exception)obj2);
}
/// <summary>
/// Decode exception.
/// </summary>
private static Exception DecodeException(PSObject psObject)
{
object result = RemoteHostEncoder.DecodePropertyValue(psObject, RemoteDataNameStrings.MethodException, typeof(Exception));
if (result == null)
{
return(null);
}
if (result is Exception)
{
return((Exception)result);
}
throw RemoteHostExceptions.NewDecodingFailedException();
}
private static PSObject EncodeDictionary(IDictionary dictionary)
{
if (RemoteHostEncoder.IsObjectDictionaryType(dictionary.GetType()))
{
return(RemoteHostEncoder.EncodeObjectDictionary(dictionary));
}
Hashtable hashtable = new Hashtable();
foreach (object key in (IEnumerable)dictionary.Keys)
{
hashtable.Add(RemoteHostEncoder.EncodeObject(key), RemoteHostEncoder.EncodeObject(dictionary[key]));
}
return(new PSObject((object)hashtable));
}
private static object DecodeClassOrStruct(PSObject psObject, Type type)
{
object uninitializedObject = FormatterServices.GetUninitializedObject(type);
foreach (PSPropertyInfo property in psObject.Properties)
{
FieldInfo field = type.GetField(property.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property.Value == null)
{
throw RemoteHostExceptions.NewDecodingFailedException();
}
field.SetValue(uninitializedObject, RemoteHostEncoder.DecodeObject(property.Value, field.FieldType) ?? throw RemoteHostExceptions.NewDecodingFailedException());
}
return(uninitializedObject);
}
/// <summary>
/// Decode parameters.
/// </summary>
private static object[] DecodeParameters(PSObject parametersPSObject, Type[] parameterTypes)
{
// Extract the ArrayList and decode the parameters.
ArrayList parameters = (ArrayList)parametersPSObject.BaseObject;
List <object> decodedParameters = new List <object>();
Dbg.Assert(parameters.Count == parameterTypes.Length, "Expected parameters.Count == parameterTypes.Length");
for (int i = 0; i < parameters.Count; ++i)
{
object parameter = parameters[i] == null ? null : RemoteHostEncoder.DecodeObject(parameters[i], parameterTypes[i]);
decodedParameters.Add(parameter);
}
return(decodedParameters.ToArray());
}
private static PSObject EncodeClassOrStruct(object obj)
{
PSObject emptyPsObject = RemotingEncoder.CreateEmptyPSObject();
foreach (FieldInfo field in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
object obj1 = field.GetValue(obj);
if (obj1 != null)
{
object obj2 = RemoteHostEncoder.EncodeObject(obj1);
emptyPsObject.Properties.Add((PSPropertyInfo) new PSNoteProperty(field.Name, obj2));
}
}
return(emptyPsObject);
}
private static IDictionary DecodeDictionary(PSObject psObject, Type dictionaryType)
{
if (RemoteHostEncoder.IsObjectDictionaryType(dictionaryType))
{
return(RemoteHostEncoder.DecodeObjectDictionary(psObject, dictionaryType));
}
Type[] genericArguments = dictionaryType.GetGenericArguments();
Type type1 = genericArguments[0];
Type type2 = genericArguments[1];
Hashtable baseObject = RemoteHostEncoder.SafelyGetBaseObject <Hashtable>(psObject);
IDictionary instance = (IDictionary)Activator.CreateInstance(dictionaryType);
foreach (object key in (IEnumerable)baseObject.Keys)
{
instance.Add(RemoteHostEncoder.DecodeObject(key, type1), RemoteHostEncoder.DecodeObject(baseObject[key], type2));
}
return(instance);
}
/// <summary>
/// Encode and add exception.
/// </summary>
private static void EncodeAndAddException(PSObject psObject, Exception exception)
{
RemoteHostEncoder.EncodeAndAddAsProperty(psObject, RemoteDataNameStrings.MethodException, exception);
}
/// <summary>
/// Decode return value.
/// </summary>
private static object DecodeReturnValue(PSObject psObject, Type returnType)
{
object returnValue = RemoteHostEncoder.DecodePropertyValue(psObject, RemoteDataNameStrings.MethodReturnValue, returnType);
return(returnValue);
}
private static object DecodeReturnValue(PSObject psObject, Type returnType)
{
return(RemoteHostEncoder.DecodePropertyValue(psObject, "mr", returnType));
}
private static void EncodeAndAddException(PSObject psObject, Exception exception)
{
RemoteHostEncoder.EncodeAndAddAsProperty(psObject, "me", exception);
}
