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); }