Beispiel #1
0
        internal static CimType GetCimTypeFromDotNetValueOrThrowAnException(object dotNetValue)
        {
            CimType cimTypeFromDotNetValue = CimConverter.GetCimTypeFromDotNetValue(dotNetValue);

            if (cimTypeFromDotNetValue != CimType.Unknown)
            {
                return(cimTypeFromDotNetValue);
            }
            else
            {
                throw new ArgumentException(Strings.DotNetValueToCimTypeConversionNotPossible);
            }
        }
 public static CimMethodParameter Create(string name, object value, CimFlags flags)
 {
     Microsoft.Management.Infrastructure.CimType cimTypeFromDotNetValueOrThrowAnException = CimConverter.GetCimTypeFromDotNetValueOrThrowAnException(value);
     return(Create(name, value, cimTypeFromDotNetValueOrThrowAnException, flags));
 }
Beispiel #3
0
        /// <summary>
        /// Creates a new property.
        /// This method overload tries to infer <see cref="CimType"/> from the property <paramref name="value"/>
        /// </summary>
        /// <param name="name">Name of the property</param>
        /// <param name="value">Value of the property.  <c>null</c> is the property doesn't have an associated value.</param>
        /// <param name="flags"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="name"/> is null</exception>
        /// <exception cref="ArgumentException">Thrown when the <see cref="CimType"/> cannot be inferred from the property <paramref name="value"/> </exception>
        static public CimProperty Create(string name, object value, CimFlags flags)
        {
            CimType cimType = CimConverter.GetCimTypeFromDotNetValueOrThrowAnException(value);

            return(Create(name, value, cimType, flags));
        }
Beispiel #4
0
        private static CimType GetCimTypeFromDotNetValue(object dotNetValue)
        {
            if (dotNetValue != null)
            {
                CimType cimType = CimConverter.GetCimType(dotNetValue.GetType());
                if (cimType != CimType.Unknown)
                {
                    return(cimType);
                }
            }
            IList lists = dotNetValue as IList;

            if (lists != null)
            {
                IEnumerable <CimType> cimTypes = lists.Cast <object>().Select <object, CimType>(new Func <object, CimType>(CimConverter.GetCimTypeFromDotNetValue));
                List <CimType>        list     = cimTypes.Where <CimType>((CimType x) => (x != CimType.Unknown)).Distinct <CimType>().ToList <CimType>();
                if (list.Count == 1)
                {
                    CimType item     = list[0];
                    CimType cimType1 = item;
                    switch (cimType1)
                    {
                    case CimType.Boolean:
                    {
                        return(CimType.BooleanArray);
                    }

                    case CimType.UInt8:
                    {
                        return(CimType.UInt8Array);
                    }

                    case CimType.SInt8:
                    {
                        return(CimType.SInt8Array);
                    }

                    case CimType.UInt16:
                    {
                        return(CimType.UInt16Array);
                    }

                    case CimType.SInt16:
                    {
                        return(CimType.SInt16Array);
                    }

                    case CimType.UInt32:
                    {
                        return(CimType.UInt32Array);
                    }

                    case CimType.SInt32:
                    {
                        return(CimType.SInt32Array);
                    }

                    case CimType.UInt64:
                    {
                        return(CimType.UInt64Array);
                    }

                    case CimType.SInt64:
                    {
                        return(CimType.SInt64Array);
                    }

                    case CimType.Real32:
                    {
                        return(CimType.Real32Array);
                    }

                    case CimType.Real64:
                    {
                        return(CimType.Real64Array);
                    }

                    case CimType.Char16:
                    {
                        return(CimType.Char16Array);
                    }

                    case CimType.DateTime:
                    {
                        return(CimType.DateTimeArray);
                    }

                    case CimType.String:
                    {
                        return(CimType.StringArray);
                    }

                    case CimType.Reference:
                    {
                        return(CimType.ReferenceArray);
                    }

                    case CimType.Instance:
                    {
                        return(CimType.InstanceArray);
                    }
                    }
                }
            }
            return(CimType.Unknown);
        }
Beispiel #5
0
 static CimConverter()
 {
     CimConverter.InitializeDotNetTypeToCimTypeDictionaries();
 }