Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Wmi / managed / System / Management / WMIGenerator.cs / 1305376 / WMIGenerator.cs
namespace System.Management { using System; using System.CodeDom; using System.CodeDom.Compiler; using System.IO; using System.Reflection; using System.Management; using System.Collections; using Microsoft.CSharp; using Microsoft.VisualBasic; using Microsoft.JScript; using System.Globalization; using System.Runtime.Remoting; using System.Runtime.Versioning; ////// public enum CodeLanguage { ///Defines the languages supported by the code generator. ////// A value for generating C# code. /// CSharp, ////// JScript, ///A value for generating JScript code. ////// VB, ///A value for generating Visual Basic code. ////// VJSharp, ///A value for generating Visual J# code. ////// Mcpp }; ///A value for generating Managed C++ code. ////// Used to generate a strongly-typed code class for a given WMI class. /// internal class ManagementClassGenerator { private string VSVERSION = "8.0.0.0"; private string OriginalServer = string.Empty; private string OriginalNamespace = string.Empty; private string OriginalClassName = string.Empty; private string OriginalPath = string.Empty; private bool bSingletonClass = false; private bool bUnsignedSupported = true; private string NETNamespace = string.Empty; private string arrConvFuncName = string.Empty; private string enumType = string.Empty; private const int DMTF_DATETIME_STR_LENGTH = 25; private bool bDateConversionFunctionsAdded = false; private bool bTimeSpanConversionFunctionsAdded = false; private ManagementClass classobj; private CodeDomProvider cp; private TextWriter tw = null; private string genFileName = string.Empty; private CodeTypeDeclaration cc; private CodeTypeDeclaration ccc; private CodeTypeDeclaration ecc; private CodeTypeDeclaration EnumObj; private CodeNamespace cn; private CodeMemberProperty cmp; private CodeConstructor cctor; private CodeMemberField cf; private CodeObjectCreateExpression coce; private CodeParameterDeclarationExpression cpde; private CodeIndexerExpression cie; private CodeMemberField cmf; private CodeMemberMethod cmm; private CodePropertyReferenceExpression cpre; private CodeMethodInvokeExpression cmie; private CodeExpressionStatement cmis; private CodeConditionStatement cis; private CodeBinaryOperatorExpression cboe; private CodeIterationStatement cfls; private CodeAttributeArgument caa; private CodeAttributeDeclaration cad; private ArrayList arrKeyType = new ArrayList(5); private ArrayList arrKeys = new ArrayList(5); private ArrayList BitMap = new ArrayList(5); private ArrayList BitValues = new ArrayList(5); private ArrayList ValueMap = new ArrayList(5); private ArrayList Values = new ArrayList(5); private SortedList PublicProperties = new SortedList(StringComparer.OrdinalIgnoreCase); private SortedList PublicMethods = new SortedList (StringComparer.OrdinalIgnoreCase); private SortedList PublicNamesUsed = new SortedList(StringComparer.OrdinalIgnoreCase); private SortedList PrivateNamesUsed = new SortedList(StringComparer.OrdinalIgnoreCase); private ArrayList CommentsString = new ArrayList(5); private bool bHasEmbeddedProperties = false; const int IDS_COMMENT_SHOULDSERIALIZE = 0; const int IDS_COMMENT_ISPROPNULL = 1; const int IDS_COMMENT_RESETPROP = 2; const int IDS_COMMENT_ATTRIBPROP = 3; const int IDS_COMMENT_DATECONVFUNC = 4; const int IDS_COMMENT_GETINSTANCES = 5; const int IDS_COMMENT_CLASSBEGIN = 6; const int IDS_COMMENT_PRIV_AUTOCOMMIT = 7; const int IDS_COMMENT_CONSTRUCTORS = 8; const int IDS_COMMENT_[....]_NAMESPACE = 9; const int IDS_COMMENT_CLASSNAME = 10; const int IDS_COMMENT_SYSOBJECT = 11; const int IDS_COMMENT_LATEBOUNDOBJ = 12; const int IDS_COMMENT_MGMTSCOPE = 13; const int IDS_COMMENT_AUTOCOMMITPROP = 14; const int IDS_COMMENT_MGMTPATH = 15; const int IDS_COMMENT_PROP_TYPECONVERTER = 16; const int IDS_COMMENT_SYSPROPCLASS = 17; const int IDS_COMMENT_ENUMIMPL = 18; const int IDS_COMMENT_LATEBOUNDPROP = 19; const int IDS_COMMENTS_CREATEDCLASS = 20; const int IDS_COMMENT_EMBEDDEDOBJ = 21; const int IDS_COMMENT_CURRENTOBJ = 22; const int IDS_COMMENT_FLAGFOREMBEDDED = 23; ////// public ManagementClassGenerator() { } ///Creates an empty generator object. This is the default constructor. ////// ///Creates a generator object and initializes it /// with the specified ///. object for which the code is to be generated. public ManagementClassGenerator(ManagementClass cls) { this.classobj = cls; } /// /// /// Indicates if a class for handling system properties should be included. /// Indicates if the generated code is for a class that handles system properties. ////// Returns a ///for /// this class. /// ///Returns the ///for the WMI class. /// public CodeTypeDeclaration GenerateCode(bool includeSystemProperties ,bool systemPropertyClass) { CodeTypeDeclaration retType; if (systemPropertyClass == true) { //Initialize the public attributes . private variables InitilializePublicPrivateMembers(); retType = GenerateSystemPropertiesClass(); } else { CheckIfClassIsProperlyInitialized(); InitializeCodeGeneration(); retType = GetCodeTypeDeclarationForClass(includeSystemProperties); } return retType; } ///If includeSystemProperties is ///, /// the ManagementSystemProperties class is included in the generated class definition. /// This parameter is ignored if systemPropertyClass is . /// Generates a strongly-typed code class for the specified language provider (C#, Visual Basic or JScript) /// and writes it to the specified file. /// /// The language to generate in. /// The path to the file where the generated code should be stored. /// The .NET namespace into which the class is generated. [ResourceExposure(ResourceScope.None),ResourceConsumption(ResourceScope.Machine,ResourceScope.Machine)] public bool GenerateCode(CodeLanguage lang ,String filePath,String netNamespace) { // check for proper arguments if (filePath == null ) { throw new ArgumentOutOfRangeException (GetString("NULLFILEPATH_EXCEPT")); } if (filePath.Length == 0) { throw new ArgumentOutOfRangeException (GetString("EMPTY_FILEPATH_EXCEPT")); } NETNamespace = netNamespace; CheckIfClassIsProperlyInitialized(); // Initialize Code Generator InitializeCodeGeneration(); //Now create the filestream (output file) tw = new StreamWriter(new FileStream (filePath,FileMode.Create),System.Text.Encoding.UTF8); return GenerateAndWriteCode(lang); } ////// Checks if mandatory properties are properly initialized. /// void CheckIfClassIsProperlyInitialized() { if (classobj == null) { if (OriginalNamespace == null || ( OriginalNamespace != null && OriginalNamespace.Length == 0)) { throw new ArgumentOutOfRangeException (GetString("NAMESPACE_NOTINIT_EXCEPT")); } if (OriginalClassName == null || ( OriginalClassName != null && OriginalClassName.Length == 0)) { throw new ArgumentOutOfRangeException (GetString("CLASSNAME_NOTINIT_EXCEPT")); } } } private void InitializeCodeGeneration() { //First try to get the class object for the given WMI Class. //If we cannot get it then there is no point in continuing //as we won't have any information for the code generation. InitializeClassObject(); //Initialize the public attributes . private variables InitilializePublicPrivateMembers(); //First form the namespace for the generated class. //The namespace will look like System.Wmi.Root.Cimv2.Win32 //for the path \\root\cimv2:Win32_Service and the class name will be //Service. ProcessNamespaceAndClassName(); //First we will sort out the different naming collision that might occur //in the generated code. ProcessNamingCollisions(); } ////// This function will generate the code. This is the function which /// should be called for generating the code. /// /// /// Flag to indicate if system properties are to be included or not /// private CodeTypeDeclaration GetCodeTypeDeclarationForClass(bool bIncludeSystemClassinClassDef) { //Create type defination for the class cc = new CodeTypeDeclaration (PrivateNamesUsed["GeneratedClassName"].ToString()); // Adding Component as base class so as to enable drag and drop cc.BaseTypes.Add(new CodeTypeReference(PrivateNamesUsed["ComponentClass"].ToString())); AddClassComments(cc); //Generate the code for defaultNamespace //public string defNamespace { // get { // return (); // } //} GeneratePublicReadOnlyProperty(PublicNamesUsed["NamespaceProperty"].ToString(),"System.String", OriginalNamespace,false,true,GetString("COMMENT_ORIGNAMESPACE")); /* Generate the following code for className [Browsable(true)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] public string ManagementClassName { get { string strRet = CreatedClassName; if (((PrivateLateBoundObject != null) && (PrivateLateBoundObject.Path != null))) { strRet = ((string)(PrivateLateBoundObject["__CLASS"])); if (((strRet == null) || (strRet.Length == 0))) { strRet = CreatedClassName; } } return strRet; } } */ // Add a private member variable to hold the namespace of the created class // Generate a private member variable for storing the generated class Name GeneratePrivateMember(PrivateNamesUsed["CreationWmiNamespace"].ToString(),"System.String", new CodePrimitiveExpression(OriginalNamespace),true,GetString("COMMENT_CREATEDWMINAMESPACE")); GenerateClassNameProperty(); // Generate a private member variable for storing the generated class Name GeneratePrivateMember(PrivateNamesUsed["CreationClassName"].ToString(),"System.String", new CodePrimitiveExpression(OriginalClassName),true,GetString("COMMENT_CREATEDCLASS")); //public SystemPropertiesClass _SystemProps{ // get { // return (privSysProps); // } //} GeneratePublicReadOnlyProperty(PublicNamesUsed["SystemPropertiesProperty"].ToString(),PublicNamesUsed["SystemPropertiesClass"].ToString(), PrivateNamesUsed["SystemPropertiesObject"].ToString(),true,true, GetString("COMMENT_SYSOBJECT")); //public wmiObjectClass _Object{ // get { // return (privWmiObject); // } //} GeneratePublicReadOnlyProperty(PublicNamesUsed["LateBoundObjectProperty"].ToString(),PublicNamesUsed["BaseObjClass"].ToString(), PrivateNamesUsed["CurrentObject"].ToString(),true,false, GetString("COMMENT_LATEBOUNDPROP")); //public ManagementScope Scope { // get { // return privScope; // } // set { // privScope = value; // } //} GenerateScopeProperty(); //public bool AutoCommit { // get { // return AutoCommitProp;; // } // set { // AutoCommitProp; = value; // } //} GeneratePublicProperty(PublicNamesUsed["AutoCommitProperty"].ToString(),"System.Boolean", new CodeSnippetExpression(PrivateNamesUsed["AutoCommitProperty"].ToString()),false, GetString("COMMENT_AUTOCOMMITPROP"),false); //public ManagementPath Path { // get { // return privWmiObject.Path; // } // set { // if (String.Compare(value.ClassName,className,true,CultureInfo.InvariantCulture) != 0) // throw new ArgumentException("Class name doesn\'t match."); // privWmiObject.Path = value; // } //} GeneratePathProperty(); // Adding a private member for storing the ManagementScope to be used by various static methods GeneratePrivateMember(PrivateNamesUsed["statMgmtScope"].ToString(),PublicNamesUsed["ScopeClass"].ToString(), new CodePrimitiveExpression(null),true,GetString("COMMENT_STATICMANAGEMENTSCOPE")); // Generate a property "StaticScope" to set and get the static ManagementScope for the class GeneratePublicProperty(PrivateNamesUsed["staticScope"].ToString(),PublicNamesUsed["ScopeClass"].ToString(), new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()),true, GetString("COMMENT_STATICSCOPEPROPERTY"),true); // Generate a function to check if a given class can be represented // by the generated class GenerateIfClassvalidFunction(); //Now generate properties of the WMI Class GenerateProperties(); // Add Function to Initialize Member variables GenerateMethodToInitializeVariables(); //Now Generate static ConstructPath() GenerateConstructPath(); //Now create the default constructor GenerateDefaultConstructor(); GenerateInitializeObject(); if (bSingletonClass == true) { //Now Generate a constructor which accepts only the scope GenerateConstructorWithScope(); //Now Generate a constructor which accepts only the get options GenerateConstructorWithOptions(); //Now generate a constructor which accepts both scope and options GenerateConstructorWithScopeOptions(); } else { //Now create the constuctor which accepts the key values GenerateConstructorWithKeys(); //Also generate a constructor which accepts a scope and keys GenerateConstructorWithScopeKeys(); //Now generate constructor with Path & Options GenerateConstructorWithPathOptions(); //Now Generate a constructor with scope & path GenerateConstructorWithScopePath(); //Now Generate the GetInstances() GenerateGetInstancesWithNoParameters(); //Now Generate the GetInstances(condition) GenerateGetInstancesWithCondition(); //Now Generate the GetInstances(propertylist) GenerateGetInstancesWithProperties(); //Now Generate the GetInstances(condition,propertylist) GenerateGetInstancesWithWhereProperties(); //Now Generate the GetInstances(scope) GenerateGetInstancesWithScope(); //Now Generate the GetInstances(scope,condition) GenerateGetInstancesWithScopeCondition(); //Now Generate the GetInstances(scope,propertylist) GenerateGetInstancesWithScopeProperties(); //Now Generate the GetInstances(scope,condition,propertylist) GenerateGetInstancesWithScopeWhereProperties(); //Generate the Collection Class GenerateCollectionClass(); } //Now create constructor with path object GenerateConstructorWithPath(); //Now Generate the constructor with path,scope,options GenerateConstructorWithScopePathOptions(); //Now generate Constructor with latebound Object GenarateConstructorWithLateBound(); //Now generate Constructor with latebound Object // and the object is an embedded object GenarateConstructorWithLateBoundForEmbedded(); // Generate static CreateInstance() to create instance of the class GenerateCreateInstance(); // Generate static DeleteInstance() to delete instance GenerateDeleteInstance(); //Now Enumerate all the methods GenerateMethods(); //Now declare the private class variables //private Wmi_SystemProps SystemProps GeneratePrivateMember(PrivateNamesUsed["SystemPropertiesObject"].ToString(),PublicNamesUsed["SystemPropertiesClass"].ToString(),null); //private WmiObject privObject GeneratePrivateMember(PrivateNamesUsed["LateBoundObject"].ToString(),PublicNamesUsed["LateBoundClass"].ToString(),GetString("COMMENT_LATEBOUNDOBJ")); //private Internal AutoCommitProperty GeneratePrivateMember(PrivateNamesUsed["AutoCommitProperty"].ToString(),"System.Boolean" ,new CodePrimitiveExpression(true),false,GetString("COMMENT_PRIVAUTOCOMMIT")); //private WmiObject Embedded object GeneratePrivateMember(PrivateNamesUsed["EmbeddedObject"].ToString(),PublicNamesUsed["BaseObjClass"].ToString(),GetString("COMMENT_EMBEDDEDOBJ")); //private WmiObject for current object used GeneratePrivateMember(PrivateNamesUsed["CurrentObject"].ToString(),PublicNamesUsed["BaseObjClass"].ToString(),GetString("COMMENT_CURRENTOBJ")); //private WmiObject for current object used GeneratePrivateMember(PrivateNamesUsed["IsEmbedded"].ToString(),"System.Boolean",new CodePrimitiveExpression(false),false,GetString("COMMENT_FLAGFOREMBEDDED")); //Now generate the Type Converter class also cc.Members.Add(GenerateTypeConverterClass()); if (bIncludeSystemClassinClassDef) { cc.Members.Add(GenerateSystemPropertiesClass()); } if(bHasEmbeddedProperties) { AddCommentsForEmbeddedProperties(); } // Added at the end so that this comment is the last comment just before declaring the class cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_CLASSBEGIN") + OriginalClassName)); return cc; } bool GenerateAndWriteCode(CodeLanguage lang) { if (InitializeCodeGenerator(lang) == false) { return false; } //Now Initialize the code class for generation InitializeCodeTypeDeclaration(lang); // Call this function to create CodeTypeDeclaration for the WMI class GetCodeTypeDeclarationForClass(true); // Trying to resolve the classname with a identifier cc.Name = cp.CreateValidIdentifier(cc.Name); //As we have finished the class definition, generate the class code NOW!!!!! cn.Types.Add (cc); //throw new Exception("about to call GenerateCodeFromNamespace"); try { cp.GenerateCodeFromNamespace (cn, tw, new CodeGeneratorOptions()); } finally { //tw.Flush(); tw.Close(); } return true; } /// /// Function for initializing the class object that will be used to get all the /// method and properties of the WMI Class for generating the code. /// private void InitializeClassObject() { //First try to connect to WMI and get the class object. // If it fails then no point in continuing // If object is not initialized by the constructor if (classobj == null) { ManagementPath thePath; if (OriginalPath.Length != 0) { thePath = new ManagementPath(OriginalPath); // classobj = new ManagementClass (OriginalPath); } else { thePath = new ManagementPath(); if (OriginalServer.Length != 0) thePath.Server = OriginalServer; thePath.ClassName = OriginalClassName; thePath.NamespacePath = OriginalNamespace; // classobj = new ManagementClass (thePath); /* throw new Exception("OriginalServer is " + OriginalServer + " OriginalNamespace is " + OriginalNamespace + " OriginalClassName is " + OriginalClassName + " results in " + thePath.Path); */ } classobj = new ManagementClass (thePath); } else { // Get the common properties ManagementPath thePath = classobj.Path; OriginalServer = thePath.Server; OriginalClassName = thePath.ClassName; OriginalNamespace = thePath.NamespacePath; char[] arrString = OriginalNamespace.ToCharArray(); // Remove the server from the namespace if (arrString.Length >= 2 && arrString[0] == '\\' && arrString[1] == '\\') { bool bStart = false; int Len = OriginalNamespace.Length; OriginalNamespace = string.Empty; for (int i = 2 ; i < Len ; i++) { if (bStart == true) { OriginalNamespace = OriginalNamespace + arrString[i]; } else if (arrString[i] == '\\') { bStart = true; } } } } //throw new Exception("classobj's path is " + classobj.Path.Path); try { classobj.Get(); } catch(ManagementException) { throw ; } //By default all classes are non-singleton(???) bSingletonClass = false; foreach (QualifierData q in classobj.Qualifiers) { if (String.Compare(q.Name,"singleton",StringComparison.OrdinalIgnoreCase) == 0) { //This is a singleton class bSingletonClass = true; break; } } } ////// This functrion initializes the public attributes and private variables /// list that will be used in the generated code. /// void InitilializePublicPrivateMembers() { //Initialize the public members PublicNamesUsed.Add("SystemPropertiesProperty","SystemProperties"); PublicNamesUsed.Add("LateBoundObjectProperty","LateBoundObject"); PublicNamesUsed.Add("NamespaceProperty","OriginatingNamespace"); PublicNamesUsed.Add("ClassNameProperty","ManagementClassName"); PublicNamesUsed.Add("ScopeProperty","Scope"); PublicNamesUsed.Add("PathProperty","Path"); PublicNamesUsed.Add("SystemPropertiesClass","ManagementSystemProperties"); PublicNamesUsed.Add("LateBoundClass","System.Management.ManagementObject"); PublicNamesUsed.Add("PathClass","System.Management.ManagementPath"); PublicNamesUsed.Add("ScopeClass","System.Management.ManagementScope"); PublicNamesUsed.Add("QueryOptionsClass","System.Management.EnumerationOptions"); PublicNamesUsed.Add("GetOptionsClass","System.Management.ObjectGetOptions"); PublicNamesUsed.Add("ArgumentExceptionClass","System.ArgumentException"); PublicNamesUsed.Add("QueryClass","SelectQuery"); PublicNamesUsed.Add("ObjectSearcherClass","System.Management.ManagementObjectSearcher"); PublicNamesUsed.Add("FilterFunction","GetInstances"); PublicNamesUsed.Add("ConstructPathFunction","ConstructPath"); PublicNamesUsed.Add("TypeConverter","TypeConverter"); PublicNamesUsed.Add("AutoCommitProperty","AutoCommit"); PublicNamesUsed.Add("CommitMethod","CommitObject"); PublicNamesUsed.Add("ManagementClass","System.Management.ManagementClass"); PublicNamesUsed.Add("NotSupportedExceptClass","System.NotSupportedException"); PublicNamesUsed.Add("BaseObjClass","System.Management.ManagementBaseObject"); PublicNamesUsed.Add("OptionsProp","Options"); PublicNamesUsed.Add("ClassPathProperty","ClassPath"); PublicNamesUsed.Add("CreateInst","CreateInstance"); PublicNamesUsed.Add("DeleteInst","Delete"); // Adding this so that the namespace resolving routine does not name // any properties with the name "System" PublicNamesUsed.Add("SystemNameSpace","System"); PublicNamesUsed.Add("ArgumentOutOfRangeException","System.ArgumentOutOfRangeException"); PublicNamesUsed.Add("System","System"); PublicNamesUsed.Add("Other","Other"); PublicNamesUsed.Add("Unknown","Unknown"); PublicNamesUsed.Add("PutOptions","System.Management.PutOptions"); PublicNamesUsed.Add("Type","System.Type"); PublicNamesUsed.Add("Boolean","System.Boolean"); PublicNamesUsed.Add("ValueType", "System.ValueType"); PublicNamesUsed.Add("Events1", "Events"); PublicNamesUsed.Add("Component1", "Component"); //Initialize the Private Members PrivateNamesUsed.Add("SystemPropertiesObject","PrivateSystemProperties"); PrivateNamesUsed.Add("LateBoundObject","PrivateLateBoundObject"); PrivateNamesUsed.Add("AutoCommitProperty","AutoCommitProp"); PrivateNamesUsed.Add("Privileges","EnablePrivileges"); PrivateNamesUsed.Add("ComponentClass","System.ComponentModel.Component"); PrivateNamesUsed.Add("ScopeParam","mgmtScope"); PrivateNamesUsed.Add("NullRefExcep","System.NullReferenceException"); PrivateNamesUsed.Add("ConverterClass","WMIValueTypeConverter"); PrivateNamesUsed.Add("EnumParam","enumOptions"); PrivateNamesUsed.Add("CreationClassName" , "CreatedClassName"); PrivateNamesUsed.Add("CreationWmiNamespace" , "CreatedWmiNamespace"); PrivateNamesUsed.Add("ClassNameCheckFunc","CheckIfProperClass"); PrivateNamesUsed.Add("EmbeddedObject","embeddedObj"); PrivateNamesUsed.Add("CurrentObject","curObj"); PrivateNamesUsed.Add("IsEmbedded","isEmbedded"); PrivateNamesUsed.Add("ToDateTimeMethod","ToDateTime"); PrivateNamesUsed.Add("ToDMTFDateTimeMethod" , "ToDmtfDateTime"); PrivateNamesUsed.Add("ToDMTFTimeIntervalMethod" , "ToDmtfTimeInterval"); PrivateNamesUsed.Add("ToTimeSpanMethod" , "ToTimeSpan"); PrivateNamesUsed.Add("SetMgmtScope" , "SetStaticManagementScope"); PrivateNamesUsed.Add("statMgmtScope" , "statMgmtScope"); PrivateNamesUsed.Add("staticScope" , "StaticScope"); PrivateNamesUsed.Add("initVariable", "Initialize"); PrivateNamesUsed.Add("putOptions", "putOptions"); PrivateNamesUsed.Add("InitialObjectFunc" , "InitializeObject"); } ////// This function will solve the naming collisions that might occur /// due to the collision between the local objects of the generated /// class and the properties/methos of the original WMI Class. /// void ProcessNamingCollisions() { if (classobj.Properties != null) { foreach(PropertyData prop in classobj.Properties) { PublicProperties.Add(prop.Name,prop.Name); } } if (classobj.Methods != null) { foreach(MethodData meth in classobj.Methods) { PublicMethods.Add(meth.Name,meth.Name); } } int nIndex; //Process the collisions here //We will check each public names with the property names here. foreach(String s in PublicNamesUsed.Values) { nIndex = IsContainedIn(s,ref PublicProperties); if ( nIndex != -1) { //We had found a collision with a public property //So we will resolve the collision by changing the property name //and continue PublicProperties.SetByIndex(nIndex,ResolveCollision(s,false)); continue; } nIndex = IsContainedIn(s,ref PublicMethods); if (nIndex != -1) { //We had found a collision with a public method //So we will resolve the collision by changing the method name //and continue PublicMethods.SetByIndex(nIndex,ResolveCollision(s,false)); continue; } } //Now we will check for collision against private variables foreach(String s in PublicProperties.Values) { nIndex = IsContainedIn(s,ref PrivateNamesUsed); if (nIndex != -1) { //We had found a collision with a public property //So we will resolve the collision by changing the private name //and continue PrivateNamesUsed.SetByIndex(nIndex,ResolveCollision(s,false)); } } foreach(String s in PublicMethods.Values) { nIndex = IsContainedIn(s,ref PrivateNamesUsed); if (nIndex != -1) { //We had found a collision with a public method //So we will resolve the collision by changing the private name //and continue PrivateNamesUsed.SetByIndex(nIndex,ResolveCollision(s,false)); } } //Now we will check for collision against Methods and Public Properties foreach(String s in PublicProperties.Values) { nIndex = IsContainedIn(s,ref PublicMethods); if (nIndex != -1) { //We had found a collision with a public property //So we will resolve the collision by changing the Public Property name //and continue PublicMethods.SetByIndex(nIndex,ResolveCollision(s,false)); } } //Now we will create the CollectionClass and Enumerator Class names as they are dependent on the //generated class name and the generated class name might have changed due to collision string strTemp = PrivateNamesUsed["GeneratedClassName"].ToString()+"Collection"; PrivateNamesUsed.Add("CollectionClass",ResolveCollision(strTemp,true)); strTemp = PrivateNamesUsed["GeneratedClassName"].ToString()+"Enumerator"; PrivateNamesUsed.Add("EnumeratorClass",ResolveCollision(strTemp,true)); } ////// This function is used to resolve (actually generate a new name) collision /// between the generated class properties/variables with WMI methods/properties. /// This function safely assumes that there will be atleast one string left /// in the series prop0, prop1 ...prop(maxInt) . Otherwise this function will /// enter an infinite loop. May be we can avoid this through something, which /// i will think about it later /// /// /// private String ResolveCollision(string inString,bool bCheckthisFirst) { string strTemp = inString; bool bCollision = true; int k = -1; string strToAdd = ""; if (bCheckthisFirst == false) { k++; strTemp = strTemp + strToAdd +k.ToString((IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32))); } while(bCollision == true) { if (IsContainedIn(strTemp,ref PublicProperties) == -1) { if (IsContainedIn(strTemp,ref PublicMethods) == -1) { if (IsContainedIn(strTemp,ref PublicNamesUsed) == -1) { if (IsContainedIn(strTemp,ref PrivateNamesUsed) == -1) { //So this is not colliding with anything. bCollision = false; break; } } } } try { k++; } catch(OverflowException) { strToAdd = strToAdd + "_"; k = 0; } strTemp = inString + strToAdd +k.ToString((IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32))); } if(strTemp.Length > 0) { string strFirstChar = strTemp.Substring(0,1).ToUpper(CultureInfo.InvariantCulture); strTemp = strFirstChar + strTemp.Substring(1,strTemp.Length -1); } return strTemp; } ////// This function processes the WMI namespace and WMI classname and converts them to /// the namespace used to generate the class and the classname. /// private void ProcessNamespaceAndClassName() { string strClass = string.Empty; string strNs = string.Empty; // if Namespace is not alread set then construct the namespace if (NETNamespace.Length == 0) { strNs = OriginalNamespace; strNs = strNs.Replace ('\\','.'); // strNs = "System.Management." + strNs; strNs = strNs.ToUpper(CultureInfo.InvariantCulture); } else { strNs = NETNamespace; } if (OriginalClassName.IndexOf('_') > 0) { strClass = OriginalClassName.Substring(0,OriginalClassName.IndexOf('_')); // if Namespace is not alread set then construct the namespace if (NETNamespace.Length == 0) { strNs += "."; strNs += strClass; } //Now trim the class name without the first '_' strClass = OriginalClassName.Substring(OriginalClassName.IndexOf('_')+1); } else { strClass = OriginalClassName; } // Check if the name of the class starts with a charachter. If not add "C" to the begining of the name if(Char.IsLetter(strClass[0]) == false) { strClass = "C" + strClass; } strClass = ResolveCollision (strClass, true); // Try to get a type from any of the namespace which are used in the generated code and see if // it collides with any of the standard classes. if(Type.GetType("System." + strClass) != null || Type.GetType("System.ComponentModel." + strClass) != null || Type.GetType("System.Management." + strClass) != null || Type.GetType("System.Collections." + strClass) != null || Type.GetType("System.Globalization." + strClass) != null ) { PublicNamesUsed.Add(strClass,strClass); strClass = ResolveCollision(strClass,true); } PrivateNamesUsed.Add ("GeneratedClassName", strClass); PrivateNamesUsed.Add("GeneratedNamespace",strNs); // PrivateNamesUsed.Add("ConverterClass",strClass+"Converter"); } private void InitializeCodeTypeDeclaration(CodeLanguage lang) { //Comment statement //Early Bound Managed Code Wrapper for WMI class//ccs = new CodeCommentStatement (String.Format ("Early Bound Managed Code Wrapper for WMI class {0}",OriginalClassName)); //cg.GenerateCodeFromStatement (ccs, tw, new CodeGeneratorOptions()); //Now add the import statements cn = new CodeNamespace(PrivateNamesUsed["GeneratedNamespace"].ToString()); cn.Imports.Add (new CodeNamespaceImport("System")); cn.Imports.Add (new CodeNamespaceImport("System.ComponentModel")); cn.Imports.Add (new CodeNamespaceImport("System.Management")); cn.Imports.Add(new CodeNamespaceImport("System.Collections")); cn.Imports.Add(new CodeNamespaceImport("System.Globalization")); if(lang == CodeLanguage.VB) { cn.Imports.Add(new CodeNamespaceImport("Microsoft.VisualBasic")); } } /// /// This function generates the code for the read only property. /// The generated code will be of the form /// public <propType> <propName>{ /// get { /// return (<propValue>); /// } /// } /// /// /// /// /// /// /// private void GeneratePublicReadOnlyProperty(string propName, string propType, object propValue,bool isLiteral,bool isBrowsable,string Comment) { cmp = new CodeMemberProperty (); cmp.Name = propName; cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cmp.Type = new CodeTypeReference(propType); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(isBrowsable); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); caa = new CodeAttributeArgument(); caa.Value = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DesignerSerializationVisibility"),"Hidden"); cad = new CodeAttributeDeclaration(); cad.Name = "DesignerSerializationVisibility"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); if (isLiteral == true) { cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodeSnippetExpression(propValue.ToString()))); } else { cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression(propValue))); } cc.Members.Add (cmp); if(Comment != null && Comment.Length != 0 ) { cmp.Comments.Add(new CodeCommentStatement(Comment)); } } private void GeneratePublicProperty(string propName,string propType, CodeExpression Value,bool isBrowsable,string Comment,bool isStatic) { cmp = new CodeMemberProperty(); cmp.Name = propName; cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp.Type = new CodeTypeReference(propType); if(isStatic) { cmp.Attributes = cmp.Attributes | MemberAttributes.Static; } caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(isBrowsable); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); // If the property is not Path then add an attribb DesignerSerializationVisibility // to indicate that the property is to be hidden for designer serilization. if (IsDesignerSerializationVisibilityToBeSet(propName)) { caa = new CodeAttributeArgument(); caa.Value = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DesignerSerializationVisibility"),"Hidden"); cad = new CodeAttributeDeclaration(); cad.Name = "DesignerSerializationVisibility"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); } cmp.GetStatements.Add(new CodeMethodReturnStatement(Value)); cmp.SetStatements.Add(new CodeAssignStatement(Value, new CodeSnippetExpression("value"))); cc.Members.Add(cmp); if(Comment != null && Comment.Length != 0) { cmp.Comments.Add(new CodeCommentStatement(Comment)); } } void GeneratePathProperty() { cmp = new CodeMemberProperty(); cmp.Name = PublicNamesUsed["PathProperty"].ToString(); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp.Type = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); cpre = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression( PrivateNamesUsed["LateBoundObject"].ToString()), "Path"); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; cis.TrueStatements.Add(new CodeMethodReturnStatement(cpre)); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); cmp.GetStatements.Add(cis); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; CodeConditionStatement cis1 = new CodeConditionStatement(); cmie = new CodeMethodInvokeExpression(); cmie.Method.MethodName = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodeVariableReferenceExpression("value")); cmie.Parameters.Add(new CodePrimitiveExpression(null)); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = cmie; cboe1.Right = new CodePrimitiveExpression(true); cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; cis1.Condition = cboe1; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentExceptionClass"].ToString()); coce.Parameters.Add(new CodePrimitiveExpression(GetString("CLASSNOT_FOUND_EXCEPT"))); cis1.TrueStatements.Add(new CodeThrowExceptionStatement(coce)); cis.TrueStatements.Add(cis1); cis.TrueStatements.Add(new CodeAssignStatement(cpre, new CodeSnippetExpression("value"))); cmp.SetStatements.Add(cis); cc.Members.Add(cmp); cmp.Comments.Add(new CodeCommentStatement(GetString("COMMENT_MGMTPATH"))); } ////// Function for generating the helper class "ManagementSystemProperties" which is /// used for seperating the system properties from the other properties. This is used /// just to make the drop down list in the editor to look good. /// CodeTypeDeclaration GenerateSystemPropertiesClass() { CodeTypeDeclaration SysPropsClass = new CodeTypeDeclaration(PublicNamesUsed["SystemPropertiesClass"].ToString()); SysPropsClass.TypeAttributes =TypeAttributes.NestedPublic; //First create the constructor // public ManagementSystemProperties(ManagementObject obj) cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()); cpde.Name = "ManagedObject"; cctor.Parameters.Add(cpde); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()),new CodeVariableReferenceExpression("ManagedObject"))); SysPropsClass.Members.Add(cctor); caa = new CodeAttributeArgument(); caa.Value = new CodeTypeOfExpression (typeof(System.ComponentModel.ExpandableObjectConverter)) ; cad = new CodeAttributeDeclaration(); cad.Name = PublicNamesUsed["TypeConverter"].ToString(); cad.Arguments.Add(caa); SysPropsClass.CustomAttributes.Add(cad); char [] strPropTemp; char [] strPropName; int i = 0; foreach (PropertyData prop in classobj.SystemProperties) { cmp = new CodeMemberProperty (); //All properties are browsable by default. caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); //Now we will have to find the occurance of the first character and trim all the characters before that strPropTemp = prop.Name.ToCharArray(); for(i=0;i < strPropTemp.Length;i++) { if (Char.IsLetterOrDigit(strPropTemp[i]) == true) { break; } } if (i == strPropTemp.Length) { i = 0; } strPropName = new char[strPropTemp.Length - i]; for(int j=i;j < strPropTemp.Length;j++) { strPropName[j - i] = strPropTemp[j]; } cmp.Name = (new string(strPropName)).ToUpper(CultureInfo.InvariantCulture); //ConvertToTitleCase(new string(strPropName)); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp.Type = ConvertCIMType(prop.Type,prop.IsArray); cie = new CodeIndexerExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()), new CodeExpression[] {new CodePrimitiveExpression(prop.Name)}); cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodeCastExpression(cmp.Type,cie))); SysPropsClass.Members.Add(cmp); } //private WmiObject _privObject cf = new CodeMemberField(); cf.Name = PrivateNamesUsed["LateBoundObject"].ToString(); cf.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cf.Type = new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()); SysPropsClass.Members.Add(cf); SysPropsClass.Comments.Add(new CodeCommentStatement(GetString("COMMENT_SYSPROPCLASS"))); return SysPropsClass; } ////// This function will enumerate all the properties (except systemproperties) /// of the WMI class and will generate them as properties of the managed code /// wrapper class. /// void GenerateProperties() { bool bRead; bool bWrite; bool bStatic; bool bDynamicClass = IsDynamicClass(); CodeMemberMethod cmm2 = null; CodeMemberProperty cmp2 = null; string IsValidPropName = string.Empty; bool bDateIsTimeInterval = false; for(int i=0;i< PublicProperties.Count;i++) { bDateIsTimeInterval = false; PropertyData prop = classobj.Properties[PublicProperties.GetKey(i).ToString()]; bRead = true; //All properties are readable by default bWrite = true; //All properties are writeable by default bStatic = false; //By default all properties are non static cmp = new CodeMemberProperty (); cmp.Name = PublicProperties[prop.Name].ToString(); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp.Type = ConvertCIMType(prop.Type,prop.IsArray); if(prop.Type == CimType.DateTime) { CodeTypeReference dateType = cmp.Type; // Check if it is Time interval and if so change the type to Time Interval bDateIsTimeInterval = GetDateTimeType(prop,ref dateType); cmp.Type = dateType; } // Check if the property is a of type ManagementBaseObject // or array of ManagementBaseObject. If so then the property // is of type embedded object if((cmp.Type.ArrayRank == 0 && cmp.Type.BaseType == new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()).BaseType) || cmp.Type.ArrayRank > 0 && cmp.Type.ArrayElementType .BaseType == new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()).BaseType) { bHasEmbeddedProperties = true; } // Method for IsNull property IsValidPropName = "Is" + PublicProperties[prop.Name].ToString() + "Null"; cmp2 = new CodeMemberProperty (); cmp2.Name = IsValidPropName; cmp2.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp2.Type = new CodeTypeReference("System.Boolean"); //All properties are browsable, by default caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(false); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp2.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp2.CustomAttributes.Add(cad); // None of the properties are seriazable thru designer caa = new CodeAttributeArgument(); caa.Value = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DesignerSerializationVisibility"),"Hidden"); cad = new CodeAttributeDeclaration(); cad.Name = "DesignerSerializationVisibility"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); cmp2.CustomAttributes.Add(cad); cie = new CodeIndexerExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), new CodeExpression[] {new CodePrimitiveExpression(prop.Name)}); bool bNullable = false; String description = ProcessPropertyQualifiers(prop,ref bRead,ref bWrite,ref bStatic,bDynamicClass,out bNullable); // If the property is not readable and not writable then don't generate the property if (bRead == false && bWrite == false) { continue; } if (description.Length != 0) { //All properties are Description, by default caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(description); cad = new CodeAttributeDeclaration(); cad.Name = "Description"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); } //WMI Values qualifier values cannot be used as //enumerator constants: they contain spaces, dots, dashes, etc. //These need to be modified, otherwise the generated file won't compile. //Uncomment the line below when that is fixed. bool isPropertyEnum = GeneratePropertyHelperEnums(prop,PublicProperties[prop.Name].ToString(), bNullable); if (bRead == true) { if(IsPropertyValueType(prop.Type) && prop.IsArray == false) { /* [Browsable(false)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] public Is Null { get { if ((PrivateLateBoundObject[ ] == null)) { return true; } else { return false; } } } */ cis = new CodeConditionStatement(); cis.Condition = new CodeBinaryOperatorExpression(cie, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); cis.TrueStatements.Add(new CodeMethodReturnStatement (new CodePrimitiveExpression(true) )); cis.FalseStatements.Add(new CodeMethodReturnStatement (new CodePrimitiveExpression(false) )); cmp2.GetStatements.Add (cis); cc.Members.Add (cmp2); // Adding TypeConverter Attribute caa = new CodeAttributeArgument(); caa.Value = new CodeTypeOfExpression (PrivateNamesUsed["ConverterClass"].ToString()) ; cad = new CodeAttributeDeclaration(); cad.Name = PublicNamesUsed["TypeConverter"].ToString(); cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); // Since functions handling Datetime, TimeSpan returns MinValue, there is no need to check for null in the property // accessor for Datetime if(prop.Type != CimType.DateTime) { cis = new CodeConditionStatement(); cis.Condition = new CodeBinaryOperatorExpression(cie, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); if (isPropertyEnum) { if(prop.IsArray) { cis.TrueStatements.Add(new CodeMethodReturnStatement (new CodePrimitiveExpression(null))); } else { //if ((curObj[" "] == null)) //{ // return (( )(System.Convert.ToInt32(0))); //} //return ( )System.Convert.ToInt32(0); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cmie.Parameters.Add(new CodePrimitiveExpression(prop.NullEnumValue)); cmie.Method.MethodName = arrConvFuncName; cis.TrueStatements.Add(new CodeMethodReturnStatement (new CodeCastExpression(cmp.Type,cmie ))); } } else { // if ((curObj[" "] == null)) //{ // return System.Convert. (0); //} //return (( )(curObj[" "])) ; cmie = new CodeMethodInvokeExpression(); cmie.Parameters.Add(new CodePrimitiveExpression(prop.NullEnumValue)); cmie.Method.MethodName = GetConversionFunction(prop.Type); cmie.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); if(prop.IsArray) { CodeExpression [] cInit = {cmie }; cis.TrueStatements.Add(new CodeMethodReturnStatement( new CodeArrayCreateExpression(cmp.Type,cInit))); } else { // return ( )System.Convert. (0); cis.TrueStatements.Add(new CodeMethodReturnStatement (cmie)); } } cmp.GetStatements.Add (cis); } /* private bool ShouldSerialize () { if(Is Null == true) return false; return true; } */ cmm = new CodeMemberMethod(); cmm.Name = "ShouldSerialize" + PublicProperties[prop.Name].ToString(); cmm.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmm.ReturnType = new CodeTypeReference("System.Boolean"); CodeConditionStatement cis2 = new CodeConditionStatement(); cis2.Condition = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(),IsValidPropName), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); cis2.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); cmm.Statements.Add(cis2); cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false))); cc.Members.Add (cmm); } if (prop.Type == CimType.Reference) { //Call this function to add code for PropertyGet for properties like // DateTime,TimeSpan and Reference( ie. properties which require some object // to be created before returning) GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cmp.GetStatements,PublicNamesUsed["PathClass"].ToString(),null,false); } else if (prop.Type == CimType.DateTime) { //Call this function to add code for PropertyGet for properties like // DateTime ,TimeSpan and Reference( ie. properties which require some object // to be created before returning) if(bDateIsTimeInterval) { GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cmp.GetStatements,"System.TimeSpan",null,false); } else { GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cmp.GetStatements,"System.DateTime",null,false); } } else { if (isPropertyEnum) { if(prop.IsArray) { AddGetStatementsForEnumArray(cie,cmp); } else { cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cmie.Parameters.Add(cie); cmie.Method.MethodName = arrConvFuncName; cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodeCastExpression(cmp.Type,cmie ))); } } else { cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodeCastExpression(cmp.Type,cie))); } } } if (bWrite == true) { if(bNullable) { cmm2 = new CodeMemberMethod (); cmm2.Name = "Reset" + PublicProperties[prop.Name].ToString(); cmm2.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmm2.Statements.Add(new CodeAssignStatement(cie,new CodePrimitiveExpression(null))); } // if the type of the property is CIM_REFERENCE then just get the // path as string and update the property if (prop.Type == CimType.Reference) { //Call this function to add code for PropertySet for properties like // DateTime,TimeSpan and Reference( ie. properties which require some object // to be created before returning) AddPropertySet(cie,prop.IsArray,cmp.SetStatements,PublicNamesUsed["PathClass"].ToString(),null); } else if (prop.Type == CimType.DateTime) { //Call this function to add code for PropertySet for properties like // DateTime ,TimeSpan and Reference( ie. properties which require some object // to be created before returning) if(bDateIsTimeInterval) { AddPropertySet(cie,prop.IsArray,cmp.SetStatements,"System.TimeSpan",null); } else { AddPropertySet(cie,prop.IsArray,cmp.SetStatements,"System.DateTime",null); } } else { if ((isPropertyEnum) && (bNullable == true)) { /* if ( Values.NULL_ENUM_VALUE == value) { curObj[ ] = null; } else { curObj[ ] = value; } */ CodeConditionStatement ccs = new CodeConditionStatement(); if (prop.IsArray) { ccs.Condition = new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(PublicProperties[prop.Name].ToString() + "Values")), "NULL_ENUM_VALUE"), CodeBinaryOperatorType.ValueEquality, new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("value"), new CodePrimitiveExpression(0))); } else { ccs.Condition = new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(PublicProperties[prop.Name].ToString() + "Values")), "NULL_ENUM_VALUE"), CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("value")); } ccs.TrueStatements.Add(new CodeAssignStatement(cie,new CodePrimitiveExpression(null))); ccs.FalseStatements.Add(new CodeAssignStatement(cie,new CodeSnippetExpression("value"))); cmp.SetStatements.Add(ccs); } else { //curObj[ ] = value; cmp.SetStatements.Add(new CodeAssignStatement(cie,new CodeSnippetExpression("value"))); } } /* if (((isEmbedded == false) && (AutoCommitProp == true))) { PrivateLateBoundObject.Put(); } */ cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()); cmie.Method.MethodName = "Put"; cboe = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["AutoCommitProperty"].ToString()), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true)); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Right = cboe; cboe2.Left = cboe1; cboe2.Operator = CodeBinaryOperatorType.BooleanAnd; cis = new CodeConditionStatement(); cis.Condition = cboe2; cis.TrueStatements.Add(new CodeExpressionStatement(cmie)); cmp.SetStatements.Add(cis); if(bNullable) { cmm2.Statements.Add(cis); } } cc.Members.Add(cmp); if(bNullable & bWrite) { cc.Members.Add(cmm2); } } // Add a function to commit the changes of the objects to WMI GenerateCommitMethod(); } /// /// This function will process the qualifiers for a given WMI property and set the /// attributes of the generated property accordingly. /// string ProcessPropertyQualifiers(PropertyData prop,ref bool bRead, ref bool bWrite, ref bool bStatic,bool bDynamicClass,out bool nullable) { bool hasWrite = false; bool writeValue = false; bool bMapsFailed = false; nullable = true; // property is always readable bRead = true; bWrite = false; arrConvFuncName = "ToInt32"; enumType = "System.Int32"; string description = String.Empty; foreach (QualifierData q in prop.Qualifiers) { if (String.Compare(q.Name,"description",StringComparison.OrdinalIgnoreCase) == 0) { description = q.Value.ToString(); } else if (String.Compare(q.Name,"Not_Null",StringComparison.OrdinalIgnoreCase) == 0) { nullable = false; } else if (String.Compare(q.Name,"key",StringComparison.OrdinalIgnoreCase) == 0) { //This is a key. So push it in to the key array arrKeyType.Add(cmp.Type); arrKeys.Add(prop.Name); nullable = false; break; } else if (string.Compare(q.Name,"static",StringComparison.OrdinalIgnoreCase) == 0) { //This property is static. So add static to the Type of the object bStatic = true; cmp.Attributes |= MemberAttributes.Static; } else if (string.Compare(q.Name,"read",StringComparison.OrdinalIgnoreCase) == 0) { if ((bool)q.Value == false) { bRead = false; } else { bRead = true; } } else if (string.Compare(q.Name,"write",StringComparison.OrdinalIgnoreCase) == 0) { hasWrite = true; if ((bool)q.Value == true) { writeValue = true; } else { writeValue = false; } } // check for ValueMap/Values and BitMap/BitValues pair and create // Enum Accordingly else if (string.Compare(q.Name,"ValueMap",StringComparison.OrdinalIgnoreCase) == 0 && bMapsFailed == false) { try { ValueMap.Clear(); //Now check whether the type of the property is int if (isTypeInt(prop.Type) == true) { if (q.Value != null) { string [] strArray = (string [])q.Value; for(int i=0;i < strArray.Length ;i++) { try { arrConvFuncName = ConvertToNumericValueAndAddToArray(prop.Type,strArray[i],ValueMap,out enumType); } catch(OverflowException) { // ValueMap.Add(Convert.ToInt64(strArray[i])); // bValueMapInt64 = true; } } } } } // if the value is not a numerical, then we cannot construct a enum catch(System.FormatException) { bMapsFailed = true; ValueMap.Clear(); } catch(System.InvalidCastException ) { // This exception may occur if the qualifier value is not an array as expected ValueMap.Clear(); } } else if (string.Compare(q.Name,"Values",StringComparison.OrdinalIgnoreCase) == 0 && bMapsFailed == false) { try { Values.Clear(); if (isTypeInt(prop.Type) == true) { if (q.Value != null) { ArrayList arTemp = new ArrayList(5); string [] strArray = (string[])q.Value; for(int i=0;i < strArray.Length;i++) { if(strArray[i].Length == 0) { Values.Clear(); bMapsFailed = true; break; } string strName = ConvertValuesToName(strArray[i]); arTemp.Add(strName); } ResolveEnumNameValues(arTemp,ref Values); } } } catch(System.InvalidCastException ) { // This exception may occur if the qualifier value is not an array as expected Values.Clear(); } } else if (string.Compare(q.Name,"BitMap",StringComparison.OrdinalIgnoreCase) == 0 && bMapsFailed == false) { try { BitMap.Clear(); if (isTypeInt(prop.Type) == true) { if (q.Value != null) { string [] strArray = (string [])q.Value; for(int i=0;i < strArray.Length;i++) { BitMap.Add(ConvertBitMapValueToInt32(strArray[i])); } } } } // if the value is not a numerical, then we cannot construct a enum catch(System.FormatException) { BitMap.Clear(); bMapsFailed = true; } catch(System.InvalidCastException ) { // This exception may occur if the qualifier value is not an array as expected BitMap.Clear(); } } else if (string.Compare(q.Name,"BitValues",StringComparison.OrdinalIgnoreCase) == 0 && bMapsFailed == false) { try { BitValues.Clear(); if (isTypeInt(prop.Type) == true) { if (q.Value != null) { ArrayList arTemp = new ArrayList(5); string [] strArray = (string [])q.Value; for(int i=0;i < strArray.Length;i++) { if(strArray[i].Length == 0) { BitValues.Clear(); bMapsFailed = true; break; } string strName = ConvertValuesToName(strArray[i]); arTemp.Add(strName); } ResolveEnumNameValues(arTemp,ref BitValues); } } } catch(System.InvalidCastException ) { // This exception may occur if the qualifier value is not an array as expected BitValues.Clear(); } } } // Property is not writeable only if "read" qualifier is present and its value is "true" // Also, for dynamic classes, absence of "write" qualifier means that the property is read-only. if ((!bDynamicClass && !hasWrite )|| (!bDynamicClass && hasWrite && writeValue)|| (bDynamicClass && hasWrite && writeValue) ) { bWrite = true; } return description; } ////// This function will generate enums corresponding to the Values/Valuemap pair /// and for the BitValues/Bitmap pair. /// ////// returns if the property is an enum. This is checked by if enum is added or not /// bool GeneratePropertyHelperEnums(PropertyData prop, string strPropertyName, bool bNullable) { bool isEnumAdded = false; bool bZeroFieldInEnum = false; //Only if the property is of type int and there is atleast values qualifier on it //then we will generate an enum for the values/valuemap(if available) //Here we don't have to check explicitly for type of the property as the size of //values array will be zero if the type is not int. string strEnum = ResolveCollision(strPropertyName + "Values", true); // if there is a mismatch in the number of values and ValueMaps then // there is an error in the value maps and so don't add enum if (Values.Count > 0 && (ValueMap.Count == 0 || ValueMap.Count == Values.Count)) { if (ValueMap.Count == 0) { bZeroFieldInEnum = true; } //Now we will have to create an enum. EnumObj = new CodeTypeDeclaration(strEnum); //Now convert the type to the generated enum type if (prop.IsArray) { cmp.Type = new CodeTypeReference(strEnum, 1); } else { cmp.Type = new CodeTypeReference(strEnum); } EnumObj.IsEnum = true; EnumObj.TypeAttributes = TypeAttributes.Public; Int64 maxValue = 0; for (int i = 0; i < Values.Count; i++) { cmf = new CodeMemberField(); cmf.Name = Values[i].ToString(); if (ValueMap.Count > 0) { cmf.InitExpression = new CodePrimitiveExpression(ValueMap[i]); Int64 test = System.Convert.ToInt64(ValueMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))); if (test > maxValue) maxValue=test; if (bZeroFieldInEnum == false) { if (System.Convert.ToInt64( ValueMap[i], (IFormatProvider)CultureInfo.InvariantCulture.GetFormat( typeof(System.UInt64))) == 0) { bZeroFieldInEnum = true; } } } else { cmf.InitExpression = new CodePrimitiveExpression(i); if (i > maxValue) maxValue=i; } EnumObj.Members.Add(cmf); } // If there is no 0 valued field in enum, just add a invalid for enum // This is just to show in property browser if ((bNullable == true) && (bZeroFieldInEnum == false)) { // use the 0 enum position for NULL cmf = new CodeMemberField(); cmf.Name = "NULL_ENUM_VALUE"; cmf.InitExpression = new CodePrimitiveExpression(0); EnumObj.Members.Add(cmf); prop.NullEnumValue = 0; } else if ((bNullable == true) && (bZeroFieldInEnum == true)) { // must create an entry for NULL that is not zero and is not used // use the another unused enum position for NULL cmf = new CodeMemberField (); cmf.Name = "NULL_ENUM_VALUE"; cmf.InitExpression = new CodePrimitiveExpression((int)(maxValue+1)); EnumObj.Members.Add(cmf); prop.NullEnumValue = (int)(maxValue+1); } else if ((bNullable == false) && (bZeroFieldInEnum == false)) { // add an entry for 0 valued enum cmf = new CodeMemberField (); cmf.Name = "INVALID_ENUM_VALUE"; cmf.InitExpression = new CodePrimitiveExpression(0); EnumObj.Members.Add(cmf); prop.NullEnumValue = 0; } cc.Members.Add(EnumObj); isEnumAdded = true; } //Now clear the Values & ValueMap Array Values.Clear(); ValueMap.Clear(); bZeroFieldInEnum = false; //Only if the property is of type int and there is atleast values qualifier on it //then we will generate an enum for the values/valuemap(if available) //Here we don't have to check explicitly for type of the property as the size of //values array will be zero if the type is not int. if (BitValues.Count > 0 && (BitMap.Count == 0 || BitMap.Count == BitValues.Count)) { if(BitMap.Count == 0) { bZeroFieldInEnum = true; } //Now we will create the enum EnumObj = new CodeTypeDeclaration(strEnum); //Now convert the type to the generated enum type if (prop.IsArray) { cmp.Type = new CodeTypeReference(strEnum, 1); } else { cmp.Type = new CodeTypeReference(strEnum); } EnumObj.IsEnum = true; EnumObj.TypeAttributes = TypeAttributes.Public; Int32 bitValue = 1; Int64 maxBitValue = 0; for (int i = 0; i < BitValues.Count; i++) { cmf = new CodeMemberField(); cmf.Name = BitValues[i].ToString(); if (BitMap.Count > 0) { cmf.InitExpression = new CodePrimitiveExpression(BitMap[i]); Int64 test = System.Convert.ToInt64(BitMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))); if (test > maxBitValue) maxBitValue=test; } else { cmf.InitExpression = new CodePrimitiveExpression(bitValue); if (bitValue > maxBitValue) maxBitValue=bitValue; // Now shift 1 more bit so that we can put it for the // next element in the enum bitValue = bitValue << 1; } if(bZeroFieldInEnum == false) { if( (System.Convert.ToInt64(BitMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))) == 0) ) // Bug No: 121987 { bZeroFieldInEnum = true; } } EnumObj.Members.Add(cmf); } // If there is no 0 valued field in enum, just add a invalid for enum // This is just to show in property browser if ((bNullable == true) && (bZeroFieldInEnum == false)) { // use the 0 enum position for NULL cmf = new CodeMemberField (); cmf.Name = "NULL_ENUM_VALUE"; cmf.InitExpression = new CodePrimitiveExpression(0); EnumObj.Members.Add(cmf); prop.NullEnumValue = 0; } else if ((bNullable == true) && (bZeroFieldInEnum == true)) { // must create an entry for NULL that is not zero and is not used // use the another unused enum position for NULL cmf = new CodeMemberField (); cmf.Name = "NULL_ENUM_VALUE"; if (BitValues.Count > 30) { maxBitValue = maxBitValue + 1; } else { maxBitValue = maxBitValue << 1; } cmf.InitExpression = new CodePrimitiveExpression((int)(maxBitValue)); EnumObj.Members.Add(cmf); // just add one - we won't preserve the bit shifting but this won't be used in CIM anyway. prop.NullEnumValue = (int)(maxBitValue); } else if ((bNullable == false) && (bZeroFieldInEnum == false)) { // add an entry for 0 valued enum cmf = new CodeMemberField (); cmf.Name = "INVALID_ENUM_VALUE"; cmf.InitExpression = new CodePrimitiveExpression(0); EnumObj.Members.Add(cmf); prop.NullEnumValue = 0; } cc.Members.Add(EnumObj); isEnumAdded = true; } //Now clear the Bitmap and BitValues Array BitValues.Clear(); BitMap.Clear(); return isEnumAdded; } ////// This function generated the static function which s used to construct the path /// private static String ConstructPath(String keyName) /// { /// //FOR NON SINGLETON CLASSES /// String strPath; /// strPath = ((("\\<defNamespace>:<defClassName>"; /// strPath = ((_strPath) + (((".Key1=") + (key_Key1)))); /// strPath = ((_strPath) + (((",Key2=") + ((("\"") + (((key_Key2) + ("\"")))))))); /// return strPath; /// /// //FOR SINGLETON CLASS /// return "\\<defNameSpace>:<defClassName>=@"; /// } /// void GenerateConstructPath() { string strType; cmm = new CodeMemberMethod(); cmm.Name = PublicNamesUsed["ConstructPathFunction"].ToString(); cmm.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final; cmm.ReturnType = new CodeTypeReference("System.String"); for(int i=0; i < arrKeys.Count;i++) { strType = ((CodeTypeReference)arrKeyType[i]).BaseType; cmm.Parameters.Add(new CodeParameterDeclarationExpression(strType, "key"+arrKeys[i].ToString())); } string strPath = OriginalNamespace + ":" + OriginalClassName; if (bSingletonClass == true) { strPath = strPath + "=@"; cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(strPath))); } else { string strPathObject = "strPath"; //Declare the String strPath; cmm.Statements.Add(new CodeVariableDeclarationStatement("System.String",strPathObject,new CodePrimitiveExpression(strPath))); CodeMethodInvokeExpression cmietoAdd; for(int i=0; i < arrKeys.Count;i++) { if (((CodeTypeReference)arrKeyType[i]).BaseType == "System.String") { CodeMethodInvokeExpression cmie1 = GenerateConcatStrings(new CodeVariableReferenceExpression("key"+arrKeys[i]),new CodePrimitiveExpression("\"")); CodeMethodInvokeExpression cmie2 = GenerateConcatStrings(new CodePrimitiveExpression("\""),cmie1); CodeMethodInvokeExpression cmie3 = GenerateConcatStrings(new CodePrimitiveExpression(((i==0)?("."+arrKeys[i]+"="):(","+arrKeys[i]+"="))),cmie2); cmietoAdd = GenerateConcatStrings(new CodeVariableReferenceExpression(strPathObject),cmie3); } else { cmie = new CodeMethodInvokeExpression(); // cmie.Method.TargetObject = new CodeCastExpression(((CodeTypeReference)arrKeyType[i]),new CodeVariableReferenceExpression("key"+arrKeys[i])); // Work Around cmie.Method.TargetObject = new CodeCastExpression(new CodeTypeReference(((CodeTypeReference)arrKeyType[i]).BaseType + " "),new CodeVariableReferenceExpression("key"+arrKeys[i])); cmie.Method.MethodName = "ToString"; CodeMethodInvokeExpression cmie1 = GenerateConcatStrings(new CodePrimitiveExpression(((i==0)?("."+arrKeys[i]+"="):(","+arrKeys[i]+"="))),cmie); cmietoAdd = GenerateConcatStrings(new CodeVariableReferenceExpression(strPathObject),cmie1); } cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strPathObject),cmietoAdd)); } cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(strPathObject))); } cc.Members.Add(cmm); } ////// This function generates the default constructor. /// public Cons() { /// _privObject = new ManagementObject(); /// _privSystemProps = new ManagementSystemProperties(_privObject); /// } /// void GenerateDefaultConstructor() { cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); //If it is a singleton class, then we will make the default constructor to point to the //only object available if (bSingletonClass == true) { cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); } else { cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); } cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); cctor.Comments.Add(new CodeCommentStatement(GetString("COMMENT_CONSTRUCTORS"))); } //////This function create the constuctor which accepts the key values. ///public cons(UInt32 key_Key1, String key_Key2) :this(null,<ClassName>.ConstructPath(<key1,key2>),null) { /// } /// void GenerateConstructorWithKeys() { if (arrKeyType.Count > 0) { cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); for(int i=0; i < arrKeys.Count;i++) { cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(((CodeTypeReference)arrKeyType[i]).BaseType); cpde.Name = "key"+arrKeys[i].ToString(); cctor.Parameters.Add(cpde); } // if the key of the class maps to "System.Management.ManagementPath" type then add a dummy param // to avoid duplicate constructors if(cctor.Parameters.Count == 1 && cctor.Parameters[0].Type.BaseType == new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()).BaseType) { cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference("System.Object"); cpde.Name = "dummyParam"; cctor.Parameters.Add(cpde); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("dummyParam"),new CodePrimitiveExpression(null))); } cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); for(int i=0; i < arrKeys.Count;i++) { cmie.Parameters.Add(new CodeVariableReferenceExpression("key"+arrKeys[i])); } coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } } //////This function create the constuctor which accepts a scope and key values. ///public cons(ManagementScope scope,UInt32 key_Key1, String key_Key2) :this(scope,<ClassName>.ConstructPath(<key1,key2>),null) { /// } /// void GenerateConstructorWithScopeKeys() { cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); if (arrKeyType.Count > 0) { for(int i=0; i < arrKeys.Count;i++) { cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(((CodeTypeReference)arrKeyType[i]).BaseType); cpde.Name = "key"+arrKeys[i].ToString(); cctor.Parameters.Add(cpde); } // if the key of the class maps to "System.Management.ManagementPath" type then add a dummy param // to avoid duplicate constructors if(cctor.Parameters.Count == 2 && cctor.Parameters[1].Type.BaseType == new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()).BaseType) { cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference("System.Object"); cpde.Name = "dummyParam"; cctor.Parameters.Add(cpde); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("dummyParam"),new CodePrimitiveExpression(null))); } cmieInit.Parameters.Add(new CodeCastExpression( new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()))); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); for(int i=0; i < arrKeys.Count;i++) { cmie.Parameters.Add(new CodeVariableReferenceExpression("key"+arrKeys[i])); } coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } } ////// This function generates code for the constructor which accepts ManagementPath as the parameter. /// The generated code will look something like this /// public Cons(ManagementPath path) : this (null, path,null){ /// } /// void GenerateConstructorWithPath() { string strPathObject = "path"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); cpde.Name = strPathObject; cctor.Parameters.Add(cpde); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts ManagementPath and GetOptions /// as parameters. /// The generated code will look something like this /// public Cons(ManagementPath path, ObjectGetOptions options) : this (null, path,options){ /// } /// void GenerateConstructorWithPathOptions() { string strPathObject = "path"; string strGetOptions = "getOptions"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPathObject)); cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()),strGetOptions)); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts Scope as a string, path as a /// string and GetOptions(). /// The generated code will look something like this /// public Cons(String scope, String path, ObjectGetOptions options) : /// this (new ManagementScope(scope), new ManagementPath(path),options){ /// } /// void GenerateConstructorWithScopePath() { string strPathObject = "path"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPathObject)); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts ManagementScope as parameters. /// The generated code will look something like this /// public Cons(ManagementScope scope, ObjectGetOptions options) : this (scope, <ClassName>.ConstructPath(),null){ /// } /// void GenerateConstructorWithScope() { cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()), PrivateNamesUsed["ScopeParam"].ToString())); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject =new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts GetOptions /// as parameters. /// The generated code will look something like this /// public Cons(ObjectGetOptions options) : this (null, <ClassName>.ConstructPath(),options){ /// } /// void GenerateConstructorWithOptions() { string strGetOptions = "getOptions"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()), strGetOptions)); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodePrimitiveExpression(null)); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts ManagementScope and GetOptions /// as parameters. /// The generated code will look something like this /// public Cons(ManagementScope scope, ObjectGetOptions options) : this (scope, <ClassName>.ConstructPath(),options){ /// } /// void GenerateConstructorWithScopeOptions() { string strGetOptions = "getOptions"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()), PrivateNamesUsed["ScopeParam"].ToString())); cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()), strGetOptions)); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeTypeReferenceExpression(PrivateNamesUsed["GeneratedClassName"].ToString()); cmie.Method.MethodName = PublicNamesUsed["ConstructPathFunction"].ToString(); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(cmie); cmieInit.Parameters.Add(coce); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generated the constructor like /// public cons(ManagementScope scope, ManagamentPath path,ObjectGetOptions getOptions) /// { /// PrivateObject = new ManagementObject(scope,path,getOptions); /// PrivateSystemProperties = new ManagementSystemProperties(PrivateObject); /// } /// void GenerateConstructorWithScopePathOptions() { string strPathObject = "path"; string strGetOptions = "getOptions"; /* bool bPrivileges = true; try { classobj.Qualifiers["priveleges"].ToString(); } catch(ManagementException e) { if (e.ErrorCode == ManagementStatus.NotFound) { bPrivileges = false; } else { throw; } } */ cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPathObject)); cctor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()),strGetOptions)); CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmieInit.Method.TargetObject = new CodeThisReferenceExpression(); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); cmieInit.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cctor.Statements.Add(new CodeExpressionStatement(cmieInit)); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts ManagementObject as the parameter. /// The generated code will look something like this /// public Cons(ManagementObject theObject) { /// if (CheckIfProperClass(theObject.Scope, theObject.Path, theObject.Options) = true) { /// privObject = theObject; /// privSystemProps = new WmiSystemProps(privObject); /// curObj = privObject; /// } /// else { /// throw new ArgumentException("Class name doesn't match"); /// } /// } /// void GenarateConstructorWithLateBound() { string strLateBoundObject = "theObject"; string LateBoundSystemProperties = "SystemProperties"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(PublicNamesUsed["LateBoundClass"].ToString()); cpde.Name = strLateBoundObject; cctor.Parameters.Add(cpde); // call this to call function to initialize memeber variables InitPrivateMemberVariables(cctor); cis = new CodeConditionStatement(); cpre = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strLateBoundObject),LateBoundSystemProperties); cie = new CodeIndexerExpression(cpre,new CodePrimitiveExpression("__CLASS")); cpre = new CodePropertyReferenceExpression(cie,"Value"); cmie = new CodeMethodInvokeExpression(); cmie.Method.MethodName = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmie.Parameters.Add(new CodeVariableReferenceExpression(strLateBoundObject)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(true); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; cis.TrueStatements.Add(new CodeAssignStatement( new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()), new CodeVariableReferenceExpression(strLateBoundObject))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["SystemPropertiesClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString())); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["SystemPropertiesObject"].ToString()),coce)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentExceptionClass"].ToString()); coce.Parameters.Add(new CodePrimitiveExpression(GetString("CLASSNOT_FOUND_EXCEPT"))); cis.FalseStatements.Add(new CodeThrowExceptionStatement(coce)); cctor.Statements.Add(cis); cc.Members.Add(cctor); } ////// This function generates code for the constructor which accepts ManagementObject as the parameter. /// The generated code will look something like this /// public Cons(ManagementBaseObject theObject) { /// if (CheckIfProperClass(theObject) = true) /// { /// embeddedObj = theObject /// PrivateSystemProperties = New ManagementSystemProperties(theObject) /// curObj = embeddedObj /// isEmbedded = true /// } /// else /// { /// throw new ArgumentException("Class name doesn't match"); /// } /// } /// /// void GenarateConstructorWithLateBoundForEmbedded() { string strLateBoundObject = "theObject"; // string LateBoundSystemProperties = "SystemProperties"; cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()); cpde.Name = strLateBoundObject; cctor.Parameters.Add(cpde); // call this to call function to initialize memeber variables InitPrivateMemberVariables(cctor); cmie = new CodeMethodInvokeExpression(); cmie.Method.MethodName = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmie.Parameters.Add(new CodeVariableReferenceExpression(strLateBoundObject)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(true); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeAssignStatement( new CodeVariableReferenceExpression(PrivateNamesUsed["EmbeddedObject"].ToString()), new CodeVariableReferenceExpression(strLateBoundObject))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["SystemPropertiesClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(strLateBoundObject)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["SystemPropertiesObject"].ToString()),coce)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["EmbeddedObject"].ToString()))); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()), new CodePrimitiveExpression(true))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentExceptionClass"].ToString()); coce.Parameters.Add(new CodePrimitiveExpression(GetString("CLASSNOT_FOUND_EXCEPT"))); cis.FalseStatements.Add(new CodeThrowExceptionStatement(coce)); cctor.Statements.Add(cis); cc.Members.Add(cctor); } ////// This function generated the constructor like /// public cons(ManagementScope scope, ManagamentPath path,ObjectGetOptions getOptions) /// { /// PrivateObject = new ManagementObject(scope,path,getOptions); /// PrivateSystemProperties = new ManagementSystemProperties(PrivateObject); /// } /// void GenerateInitializeObject() { string strPathObject = "path"; string strGetOptions = "getOptions"; bool bPrivileges = true; try { classobj.Qualifiers["priveleges"].ToString(); } catch(ManagementException e) { if (e.ErrorCode == ManagementStatus.NotFound) { bPrivileges = false; } else { throw; } } CodeMemberMethod cmmInit = new CodeMemberMethod(); cmmInit.Name = PrivateNamesUsed["InitialObjectFunc"].ToString(); cmmInit.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmmInit.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cmmInit.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPathObject)); cmmInit.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()),strGetOptions)); // call this to call function to initialize memeber variables InitPrivateMemberVariables(cmmInit); //First if path is not null, then we will check whether the class name is the same. //if it is not the same, then we will throw an exception cis = new CodeConditionStatement(); cis.Condition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(strPathObject), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeConditionStatement cis1 = new CodeConditionStatement(); cmie = new CodeMethodInvokeExpression(); cmie.Method.MethodName = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmie.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmie.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(true); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis1.Condition = cboe; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentExceptionClass"].ToString()); coce.Parameters.Add(new CodePrimitiveExpression(GetString("CLASSNOT_FOUND_EXCEPT"))); cis1.TrueStatements.Add(new CodeThrowExceptionStatement(coce)); cis.TrueStatements.Add(cis1); cmmInit.Statements.Add(cis); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["LateBoundClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); coce.Parameters.Add(new CodeVariableReferenceExpression(strPathObject)); coce.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); cmmInit.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression( PrivateNamesUsed["LateBoundObject"].ToString()), coce)); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["SystemPropertiesClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString())); cmmInit.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression( PrivateNamesUsed["SystemPropertiesObject"].ToString()), coce)); cmmInit.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()))); cc.Members.Add(cmmInit); // Enable the privileges if the class has privileges qualifier if (bPrivileges == true) { //Generate the statement // Boolean bPriveleges = PrivateLateBoundObject.Scope.Options.EnablePrivileges; cpre = new CodePropertyReferenceExpression(new CodePropertyReferenceExpression( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()), PublicNamesUsed["ScopeProperty"].ToString()), "Options"), "EnablePrivileges"); cctor.Statements.Add(new CodeAssignStatement(cpre, new CodePrimitiveExpression(true))); } } ////// This function generates the WMI methods as the methods in the generated class. /// The generated code will look something like this /// public <retType> Method1(<type> param1, <type> param2,...) { /// ManagementBaseObject inParams = null; /// inParams = _privObject.GetMethodParameters("ChangeStartMode"); /// inParams["<inparam1>"] = <Value>; /// inParams["<inoutparam2>"] = <Value>; /// ................................ /// ManagementBaseObject outParams = _privObject.InvokeMethod("ChangeStartMode", inParams, null); /// inoutParam3 = (<type>)(outParams.Properties["<inoutParam3>"]); /// outParam4 = (String)(outParams.Properties["<outParam4>"]); /// ................................ /// return (<retType>)(outParams.Properties["ReturnValue"].Value); /// } /// /// The code generated changes if the method is static function /// public <retType> Method1(<type> param1, <type> param2,...) { /// ManagementBaseObject inParams = null; /// ManagementObject classObj = new ManagementObject(null, "WIN32_SHARE", null); // the clasname /// inParams = classObj.GetMethodParameters("Create"); /// inParams["<inparam1>"] = <Value>; /// inParams["<inoutparam2>"] = <Value>; /// ................................ /// ManagementBaseObject outParams = classObj.InvokeMethod("ChangeStartMode", inParams, null); /// inoutParam3 = (<type>)(outParams.Properties["<inoutParam3>"]); /// outParam4 = (String)(outParams.Properties["<outParam4>"]); /// ................................ /// return (<retType>)(outParams.Properties["ReturnValue"].Value); /// } /// /// void GenerateMethods() { string strInParams = "inParams"; string strOutParams = "outParams"; string strClassObj = "classObj"; bool bStatic = false; bool bPrivileges = false; CodePropertyReferenceExpression cprePriveleges = null; CimType cimRetType = CimType.SInt8; // Initialized to remove warnings CodeTypeReference retRefType = null; bool isRetArray = false; bool bIsCimDateTimeInterval = false; ArrayList outParamsName = new ArrayList(5); ArrayList inoutParams = new ArrayList(5); ArrayList inoutParamsType = new ArrayList(5); for(int k=0;k< PublicMethods.Count;k++) { bStatic = false; MethodData meth = classobj.Methods[PublicMethods.GetKey(k).ToString()]; string strTemp = PrivateNamesUsed["LateBoundObject"].ToString(); if (meth.OutParameters != null) { if(meth.OutParameters.Properties != null) { //First Populate the out Params name so that we can find in/out parameters foreach (PropertyData prop in meth.OutParameters.Properties) { outParamsName.Add(prop.Name); } } } cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Name = PublicMethods[meth.Name].ToString(); //Check if the method is static foreach (QualifierData q in meth.Qualifiers) { if (string.Compare(q.Name,"static",StringComparison.OrdinalIgnoreCase) == 0) { //It is a static function cmm.Attributes |= MemberAttributes.Static; bStatic = true; break; } else if (string.Compare(q.Name,"privileges",StringComparison.OrdinalIgnoreCase) == 0) { //It is a function which needs privileges to be set bPrivileges = true; } } // For Static method , the member variable "IsEmbedded" cannot be accessed cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); if(bStatic) { cmm.Statements.Add(new CodeVariableDeclarationStatement("System.Boolean","IsMethodStatic",new CodePrimitiveExpression(bStatic))); cboe.Left = new CodeVariableReferenceExpression("IsMethodStatic"); cboe.Right = new CodePrimitiveExpression(true); } else { cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); } cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; bool bfirst = true; //Generate the statement // ManagementBaseObject inParams = null; cis.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()), strInParams,new CodePrimitiveExpression(null))); if (bStatic == true) { string strPath = "mgmtPath"; CodeObjectCreateExpression cocePath = new CodeObjectCreateExpression(); cocePath.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); cocePath.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["CreationClassName"].ToString())); cis.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPath,cocePath)); CodeObjectCreateExpression coce1 = new CodeObjectCreateExpression(); coce1.CreateType = new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()); coce1.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString())); coce1.Parameters.Add(new CodeVariableReferenceExpression(strPath)); coce1.Parameters.Add(new CodePrimitiveExpression(null)); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()); coce.Parameters.Add(coce1); cis.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()),strClassObj,coce1)); strTemp = strClassObj; } if (bPrivileges == true) { //Generate the statement // Boolean bPriveleges = PrivateLateBoundObject.Scope.Options.EnablePrivileges; cprePriveleges = new CodePropertyReferenceExpression(new CodePropertyReferenceExpression( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(bStatic ? strClassObj : PrivateNamesUsed["LateBoundObject"].ToString()), PublicNamesUsed["ScopeProperty"].ToString()), "Options"), "EnablePrivileges"); cis.TrueStatements.Add(new CodeVariableDeclarationStatement("System.Boolean", PrivateNamesUsed["Privileges"].ToString(),cprePriveleges)); cis.TrueStatements.Add(new CodeAssignStatement(cprePriveleges, new CodePrimitiveExpression(true))); } //Do these things only when there is a valid InParameters if (meth.InParameters != null) { //Now put the in parameters if (meth.InParameters.Properties != null) { foreach (PropertyData prop in meth.InParameters.Properties) { bIsCimDateTimeInterval = false; if (bfirst == true) { //Now Generate the statement // inParams = privObject.GetMethodParameters(); cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strTemp), "GetMethodParameters", new CodePrimitiveExpression(meth.Name)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strInParams),cmie)); bfirst = false; } cpde = new CodeParameterDeclarationExpression(); cpde.Name = prop.Name; cpde.Type = ConvertCIMType(prop.Type,prop.IsArray); cpde.Direction = FieldDirection.In; if( prop.Type == CimType.DateTime) { CodeTypeReference dateType = cpde.Type; // Check if it is Time interval and if so change the type to Time Interval bIsCimDateTimeInterval = GetDateTimeType(prop,ref dateType); cpde.Type = dateType; } //Find out whether it is a in/out Parameter for(int i=0; i < outParamsName.Count;i++) { if (string.Compare(prop.Name,outParamsName[i].ToString(),StringComparison.OrdinalIgnoreCase) == 0) { //It is an in/out Parameter cpde.Direction = FieldDirection.Ref; inoutParams.Add(prop.Name); inoutParamsType.Add(cpde.Type); } } cmm.Parameters.Add(cpde); //Also generate the statement //inParams["PropName"] = Value; cie = new CodeIndexerExpression(new CodeVariableReferenceExpression(strInParams),new CodePrimitiveExpression(prop.Name)); // if the type of the property is CIM_REFERENCE then just get the // path as string set the property to that string if (prop.Type == CimType.Reference) { //Call this function to add code for converting the path to // string and assigning it to parameter AddPropertySet(cie,prop.IsArray,cis.TrueStatements,PublicNamesUsed["PathClass"].ToString(),new CodeVariableReferenceExpression(cpde.Name)); } else if (prop.Type == CimType.DateTime) { //Call this function to add code for converting the DateTime,TimeSpan to string // and assigning it to the parameter if(bIsCimDateTimeInterval) { AddPropertySet(cie,prop.IsArray,cis.TrueStatements,"System.TimeSpan",new CodeVariableReferenceExpression(cpde.Name)); } else { AddPropertySet(cie,prop.IsArray,cis.TrueStatements,"System.DateTime",new CodeVariableReferenceExpression(cpde.Name)); } } else { // cis.TrueStatements.Add(new CodeAssignStatement(cie,new CodeVariableReferenceExpression(cpde.Name))); if(cpde.Type.ArrayRank == 0) { // Work around cis.TrueStatements.Add(new CodeAssignStatement(cie,new CodeCastExpression(new CodeTypeReference(cpde.Type.BaseType + " "), new CodeVariableReferenceExpression(cpde.Name)))); } else { cis.TrueStatements.Add(new CodeAssignStatement(cie,new CodeCastExpression(cpde.Type,new CodeVariableReferenceExpression(cpde.Name)))); } } } } } //Now clear the outParamsName array outParamsName.Clear(); bool bInOut; bool bRetVal = false; bfirst = true; bool bInvoke = false; CodeMethodInvokeExpression cmie2 = null; //Do these only when the outParams is Valid if (meth.OutParameters != null) { if (meth.OutParameters.Properties != null) { foreach (PropertyData prop in meth.OutParameters.Properties) { bIsCimDateTimeInterval = false; if (bfirst == true) { //Now generate the statement // ManagementBaseObject outParams = privObject.InvokeMethod( ,inParams,options); cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strTemp), "InvokeMethod"); cmie.Parameters.Add(new CodePrimitiveExpression(meth.Name)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strInParams)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cis.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()),strOutParams,cmie)); bfirst = false; bInvoke = true; } bInOut = false; for(int i=0; i < inoutParams.Count;i++) { if (string.Compare(prop.Name,inoutParams[i].ToString(),StringComparison.OrdinalIgnoreCase) == 0) { bInOut = true; } } if (bInOut == true) continue; if (string.Compare(prop.Name,"ReturnValue",StringComparison.OrdinalIgnoreCase) == 0) { cmm.ReturnType = ConvertCIMType(prop.Type,prop.IsArray); bRetVal = true; cimRetType = prop.Type; if( prop.Type == CimType.DateTime) { CodeTypeReference dateType = cmm.ReturnType; // Check if it is Time interval and if so change the type to Time Interval bool isRetTypeTimeInterval = GetDateTimeType(prop,ref dateType); cmm.ReturnType = dateType; } retRefType = cmm.ReturnType; isRetArray = prop.IsArray; } else { cpde = new CodeParameterDeclarationExpression(); cpde.Name = prop.Name; cpde.Type = ConvertCIMType(prop.Type,prop.IsArray); cpde.Direction = FieldDirection.Out; cmm.Parameters.Add(cpde); if( prop.Type == CimType.DateTime) { CodeTypeReference dateType = cpde.Type; // Check if it is Time interval and if so change the type to Time Interval bIsCimDateTimeInterval = GetDateTimeType(prop,ref dateType); cpde.Type = dateType; } //Now for each out params generate the statement // = outParams.Properties[" "]; cpre = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strOutParams),"Properties"); cie = new CodeIndexerExpression(cpre,new CodePrimitiveExpression(prop.Name)); if (prop.Type == CimType.Reference) { //Call this function to add code for converting string CIM_REFERENCE // to ManagementPath GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cis.TrueStatements,PublicNamesUsed["PathClass"].ToString(),new CodeVariableReferenceExpression(prop.Name),true); } else if (prop.Type == CimType.DateTime) { //Call this function to add code for converting datetime,TimeSpan in DMTF formate // to System.DateTime if(bIsCimDateTimeInterval) { GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cis.TrueStatements,"System.TimeSpan",new CodeVariableReferenceExpression(prop.Name),true); } else { GenerateCodeForRefAndDateTimeTypes(cie,prop.IsArray,cis.TrueStatements,"System.DateTime",new CodeVariableReferenceExpression(prop.Name),true); } } else { if(prop.IsArray || prop.Type == CimType.Object) { cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name), new CodeCastExpression(ConvertCIMType(prop.Type,prop.IsArray), new CodePropertyReferenceExpression(cie,"Value")))); } else { cmie2 = new CodeMethodInvokeExpression(); cmie2.Parameters.Add(new CodePropertyReferenceExpression(cie,"Value")); cmie2.Method.MethodName = GetConversionFunction(prop.Type); cmie2.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name),cmie2)); } } //Now for each out params generate the statement if it is an embedded instance if(prop.Type == CimType.DateTime && prop.IsArray == false) { if(bIsCimDateTimeInterval) { coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cis.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name),coce)); } else { cis.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"), "MinValue"))); } } else if(IsPropertyValueType(prop.Type) && prop.IsArray == false) { cmie2 = new CodeMethodInvokeExpression(); cmie2.Parameters.Add(new CodePrimitiveExpression(0)); cmie2.Method.MethodName = GetConversionFunction(prop.Type); cmie2.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cis.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name),cmie2)); } else { cis.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(prop.Name), new CodePrimitiveExpression(null))); } } } } } if (bInvoke == false) { //Now there is no out parameters to invoke the function //So just call Invoke. cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strTemp), "InvokeMethod" ); cmie.Parameters.Add(new CodePrimitiveExpression(meth.Name)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strInParams)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); // Bug NO: 108605 cmis = new CodeExpressionStatement(cmie); cis.TrueStatements.Add(cmis); } //Now for each in/out params generate the statement // = outParams.Properties[" "]; for(int i=0;i < inoutParams.Count;i++) { cpre = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strOutParams),"Properties"); cie = new CodeIndexerExpression(cpre,new CodePrimitiveExpression(inoutParams[i].ToString())); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(inoutParams[i].ToString()), new CodeCastExpression((CodeTypeReference)inoutParamsType[i], new CodePropertyReferenceExpression(cie,"Value")))); } inoutParams.Clear(); // Assign the privileges back if (bPrivileges == true) { cis.TrueStatements.Add(new CodeAssignStatement(cprePriveleges, new CodeVariableReferenceExpression(PrivateNamesUsed["Privileges"].ToString()))); } //Now check if there is a return value. If there is one then return it from the function if (bRetVal == true) { CodeVariableDeclarationStatement cRetVal = new CodeVariableDeclarationStatement(retRefType,"retVar"); cpre = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strOutParams),"Properties"); cie = new CodeIndexerExpression(cpre,new CodePrimitiveExpression("ReturnValue")); if (retRefType.BaseType == new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()).BaseType) { cmm.Statements.Add(cRetVal); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("retVar"),new CodePrimitiveExpression(null))); //Call this function to add code for converting string CIM_REFERENCE // to ManagementPath and return GenerateCodeForRefAndDateTimeTypes(cie,isRetArray,cis.TrueStatements,PublicNamesUsed["PathClass"].ToString(),new CodeVariableReferenceExpression("retVar"),true); cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retVar"))); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); } else if (retRefType.BaseType == "System.DateTime") { cmm.Statements.Add(cRetVal); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("retVar"), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"))); //Call this function to add code for converting DMTF format string datetime to System.DateTime before returning GenerateCodeForRefAndDateTimeTypes(cie,isRetArray,cis.TrueStatements,"System.DateTime",new CodeVariableReferenceExpression("retVar"),true); cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retVar"))); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retVar"))); } else if (retRefType.BaseType == "System.TimeSpan") { cmm.Statements.Add(cRetVal); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("retVar"),coce)); //Call this function to add code for converting DMTF format string Time Interval to System.TimeSpan before returning GenerateCodeForRefAndDateTimeTypes(cie,isRetArray,cis.TrueStatements,"System.TimeSpan",new CodeVariableReferenceExpression("retVar"),true); cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retVar"))); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retVar"))); } else // if the return value is not array and not of type CimType.Object if(retRefType.ArrayRank == 0 && retRefType.BaseType != new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()).BaseType) { cmie = new CodeMethodInvokeExpression(); cmie.Parameters.Add(new CodePropertyReferenceExpression(cie,"Value")); cmie.Method.MethodName = GetConversionFunction(cimRetType); cmie.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cis.TrueStatements.Add(new CodeMethodReturnStatement(cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Parameters.Add(new CodePrimitiveExpression(0)); cmie.Method.MethodName = GetConversionFunction(cimRetType); cmie.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cis.FalseStatements.Add(new CodeMethodReturnStatement(cmie)); } // if the return type is array, then just do type casting before returning else { cis.TrueStatements.Add(new CodeMethodReturnStatement( new CodeCastExpression(retRefType,new CodePropertyReferenceExpression(cie,"Value")))); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); } } cmm.Statements.Add(cis); cc.Members.Add(cmm); } } /// /// This function returns a Collectionclass for the query /// "Select * from <ClassName>" /// This is a static method. The output is like this /// public static ServiceCollection All() /// { /// return GetInstances((System.Management.ManagementScope)null,(System.Management.EnumerateionOptions)null); /// } /// void GenerateGetInstancesWithNoParameters() { cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmie = new CodeMethodInvokeExpression(); cmie.Method.MethodName = PublicNamesUsed["FilterFunction"].ToString(); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); cmm.Comments.Add(new CodeCommentStatement(GetString("COMMENT_GETINSTANCES"))); } ////// This function will accept the condition and will return collection for the query /// "select * from <ClassName> where <condition>" /// The generated code will be like /// public static ServiceCollection GetInstances(String Condition) { /// return GetInstances(null,Condition,null); /// } /// void GenerateGetInstancesWithCondition() { string strCondition = "condition"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String",strCondition)); cmie = new CodeMethodInvokeExpression( null, //no TargetObject? PublicNamesUsed["FilterFunction"].ToString() ); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strCondition)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); } ////// This function returns the collection for the query /// "select <parameterList> from <ClassName>" /// The generated output is like /// public static ServiceCollection GetInstances(String []selectedProperties) { /// return GetInstances(null,null,selectedProperties); /// } /// void GenerateGetInstancesWithProperties() { string strSelectedProperties = "selectedProperties"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String []",strSelectedProperties)); cmie = new CodeMethodInvokeExpression( null, PublicNamesUsed["FilterFunction"].ToString() ); //cmie.MethodName = PublicNamesUsed["FilterFunction"].ToString(); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strSelectedProperties)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); } ////// This function returns the collection for the query /// "select <parameterList> from <ClassName> where <WhereClause>" /// The generated output is like /// public static ServiceCollection GetInstances(String condition, String []selectedProperties) { /// return GetInstances(null,condition,selectedProperties); /// } /// void GenerateGetInstancesWithWhereProperties() { string strSelectedProperties = "selectedProperties"; string strCondition = "condition"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String",strCondition)); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String []",strSelectedProperties)); cmie = new CodeMethodInvokeExpression( null, //no TargetObject? PublicNamesUsed["FilterFunction"].ToString() ); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strCondition)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strSelectedProperties)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); } ////// This function returns a Collectionclass for the query /// "Select * from <ClassName>" /// This is a static method. The output is like this /// public static (ObjectCollection)GetInstances(System.Management.ManagementScope mgmtScope, System.Management.EnumerationOptions enumOptions) /// { /// if ((mgmtScope == null)) /// { /// mgmtScope = new System.Management.ManagementScope(); /// mgmtScope.Path.NamespacePath = "root\\CimV2"; /// } /// System.Management.ManagementPath pathObj = new System.Management.ManagementPath(); /// pathObj.ClassName = "CIM_LogicalDisk"; /// pathObj.NamespacePath = "root\\CimV2"; /// System.Management.ManagementClass clsObject = new System.Management.ManagementClass(mgmtScope, pathObj, null); /// if ((enumOptions == null)) /// { /// enumOptions = new System.Management.EnumerationOptions(); /// enumOptions.EnsureLocatable = true; /// } /// return new ObjectCollection(clsObject.GetInstances(enumOptions)); /// } /// This method takes the scope which is useful for connection to remote machine /// void GenerateGetInstancesWithScope() { cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["QueryOptionsClass"].ToString()), PrivateNamesUsed["EnumParam"].ToString())); string strClass = "clsObject"; string pathObj = "pathObj"; cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; cis.Condition = cboe; CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityEquality; cis1.Condition = cboe1; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()),coce)); cis1.TrueStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()), "Path"),"NamespacePath"), new CodePrimitiveExpression(classobj.Scope.Path.NamespacePath))); cis1.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()))); cis.TrueStatements.Add(cis1); cmm.Statements.Add(cis); // Create a path object for the class coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),pathObj,coce)); cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(pathObj),"ClassName"), new CodePrimitiveExpression(OriginalClassName))); cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(pathObj),"NamespacePath"), new CodePrimitiveExpression(classobj.Scope.Path.NamespacePath))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); coce.Parameters.Add(new CodeVariableReferenceExpression(pathObj)); coce.Parameters.Add(new CodePrimitiveExpression(null)); cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()), strClass,coce)); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString()); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; cis.Condition = cboe; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["QueryOptionsClass"].ToString()); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString()), coce)); cis.TrueStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString()), "EnsureLocatable"), new CodePrimitiveExpression(true))); cmm.Statements.Add(cis); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(strClass),"GetInstances"); cmie.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString())); coce.Parameters.Add(cmie); cmm.Statements.Add(new CodeMethodReturnStatement(coce)); cc.Members.Add(cmm); } ////// This function will accept the condition and will return collection for the query /// "select * from <ClassName> where <condition>" /// The generated code will be like /// public static ServiceCollection GetInstances(String Condition) { /// return GetInstances(scope,Condition,null); /// } /// void GenerateGetInstancesWithScopeCondition() { string strCondition = "condition"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.String"),strCondition)); cmie = new CodeMethodInvokeExpression( null, PublicNamesUsed["FilterFunction"].ToString() ); //cmie.MethodName = PublicNamesUsed["FilterFunction"].ToString(); cmie.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmie.Parameters.Add(new CodeVariableReferenceExpression(strCondition)); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); } ////// This function returns the collection for the query /// "select <parameterList> from <ClassName>" /// The generated output is like /// public static ServiceCollection GetInstances(String []selectedProperties) { /// return GetInstances(scope,null,selectedProperties); /// } /// void GenerateGetInstancesWithScopeProperties() { string strSelectedProperties = "selectedProperties"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression(PublicNamesUsed["ScopeClass"].ToString(),PrivateNamesUsed["ScopeParam"].ToString())); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String []",strSelectedProperties)); cmie = new CodeMethodInvokeExpression( null, //no TargetObject? PublicNamesUsed["FilterFunction"].ToString() ); cmie.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); cmie.Parameters.Add(new CodePrimitiveExpression(null)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strSelectedProperties)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); cc.Members.Add(cmm); } ////// This function generates the code like /// public static ServiceCollection GetInstances(ManagementScope scope,String Condition, String[] selectedProperties) { /// if (scope == null) /// { /// scope = new ManagementScope(); /// scope.Path.NamespacePath = WMINamespace; /// } /// ManagementObjectSearcher ObjectSearcher = new ManagementObjectSearcher(scope,new SelectQuery("Win32_Service",Condition,selectedProperties)); /// QueryOptions query = new QueryOptions(); /// query.EnsureLocatable = true; /// ObjectSearcher.Options = query; /// return new ServiceCollection(ObjectSearcher.Get()); /// } /// void GenerateGetInstancesWithScopeWhereProperties() { string strCondition = "condition"; string strSelectedProperties = "selectedProperties"; string strObjectSearcher = "ObjectSearcher"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["FilterFunction"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String",strCondition)); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.String []",strSelectedProperties)); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; cis.Condition = cboe; CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityEquality; cis1.Condition = cboe1; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()),coce)); cis1.TrueStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()), "Path"),"NamespacePath"), new CodePrimitiveExpression(classobj.Scope.Path.NamespacePath))); cis1.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString()), new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()))); cis.TrueStatements.Add(cis1); cmm.Statements.Add(cis); CodeObjectCreateExpression coce1 = new CodeObjectCreateExpression(); coce1.CreateType = new CodeTypeReference(PublicNamesUsed["QueryClass"].ToString()); coce1.Parameters.Add(new CodePrimitiveExpression(OriginalClassName)); coce1.Parameters.Add(new CodeVariableReferenceExpression(strCondition)); coce1.Parameters.Add(new CodeVariableReferenceExpression(strSelectedProperties)); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ObjectSearcherClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); coce.Parameters.Add(coce1); cmm.Statements.Add(new CodeVariableDeclarationStatement(PublicNamesUsed["ObjectSearcherClass"].ToString(), strObjectSearcher,coce)); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["QueryOptionsClass"].ToString()); cmm.Statements.Add(new CodeVariableDeclarationStatement( new CodeTypeReference(PublicNamesUsed["QueryOptionsClass"].ToString()), PrivateNamesUsed["EnumParam"].ToString(),coce)); cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString()), "EnsureLocatable"), new CodePrimitiveExpression(true))); cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(strObjectSearcher), "Options"), new CodeVariableReferenceExpression(PrivateNamesUsed["EnumParam"].ToString()))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["CollectionClass"].ToString()); coce.Parameters.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(strObjectSearcher), "Get")); cmm.Statements.Add(new CodeMethodReturnStatement(coce)); cc.Members.Add(cmm); } ////// This function will add the variable as a private member to the class. /// The generated code will look like this /// private <MemberType> <MemberName>; /// void GeneratePrivateMember(string memberName,string MemberType,string Comment) { GeneratePrivateMember(memberName,MemberType,null,false,Comment); } ////// This function will add the variable as a private member to the class. /// The generated code will look like this /// private <MemberType> <MemberName> = <initValue>; /// void GeneratePrivateMember(string memberName,string MemberType,CodeExpression initExpression,bool isStatic,string Comment) { cf = new CodeMemberField(); cf.Name = memberName; cf.Attributes = MemberAttributes.Private | MemberAttributes.Final ; if(isStatic == true) { cf.Attributes = cf.Attributes | MemberAttributes.Static; } cf.Type = new CodeTypeReference(MemberType); if (initExpression != null && isStatic == true) { cf.InitExpression = initExpression; } cc.Members.Add(cf); if(Comment != null && Comment.Length != 0) { cf.Comments.Add(new CodeCommentStatement(Comment)); } } CodeTypeDeclaration GenerateTypeConverterClass() { string TypeDescriptorContextClass = "System.ComponentModel.ITypeDescriptorContext"; string contextObject = "context"; string TypeDstObject = "destinationType"; string ValueVar = "value"; string CultureInfoClass = "System.Globalization.CultureInfo"; string CultureInfoVar = "culture"; string IDictionary = "System.Collections.IDictionary"; string DictVar = "dictionary"; string propColl = "PropertyDescriptorCollection"; string AttributeVar = "attributeVar"; string baseTypeParam = "inBaseType"; string baseTypeMemberVariable = "baseConverter"; string typeMemberVariable = "baseType"; string TypeDescriptorClass = "TypeDescriptor"; string srcType = "srcType"; /* // TypeConverter to handle null values for ValueType properties public class WMIValueTypeConverter : TypeConverter */ CodeTypeDeclaration CodeConvertorClass = new CodeTypeDeclaration(PrivateNamesUsed["ConverterClass"].ToString()); CodeConvertorClass.BaseTypes.Add(PublicNamesUsed["TypeConverter"].ToString()); /* private TypeConverter baseConverter; private Type baseType; */ cf = new CodeMemberField(); cf.Name = baseTypeMemberVariable; cf.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cf.Type = new CodeTypeReference(PublicNamesUsed["TypeConverter"].ToString()); CodeConvertorClass.Members.Add(cf); cf = new CodeMemberField(); cf.Name = typeMemberVariable; cf.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cf.Type = new CodeTypeReference(PublicNamesUsed["Type"].ToString()); CodeConvertorClass.Members.Add(cf); /* public WMIValueTypeConverter(System.Type inBaseType) { baseConverter = TypeDescriptor.GetConverter(inBaseType); baseType = inBaseType; } */ cctor = new CodeConstructor(); // cctor.Attributes = MemberAttributes.Assembly; cctor.Attributes = MemberAttributes.Public ; cpde = new CodeParameterDeclarationExpression(); cpde.Name = baseTypeParam; cpde.Type = new CodeTypeReference("System.Type"); cctor.Parameters.Add(cpde); cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(TypeDescriptorClass),"GetConverter"); cmie.Parameters.Add(new CodeVariableReferenceExpression(baseTypeParam)); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(baseTypeMemberVariable),cmie)); // second assignment in ctor cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(typeMemberVariable),new CodeVariableReferenceExpression(baseTypeParam))); // add the ctor to the class CodeConvertorClass.Members.Add(cctor); /* public virtual bool CanConvertFrom(ITypeDescriptorContext context, Type srcType); { return baseType.CanConvertFrom(srcType); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "CanConvertFrom"; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.Type",srcType)); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"CanConvertFrom"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(srcType)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual bool CanConvertTo(ITypeDescriptorContext context, Type TypeDstObject); { return baseType.CanConvertTo(context,TypeDstObject); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "CanConvertTo"; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.Type",TypeDstObject)); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"CanConvertTo"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(TypeDstObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual object ConvertFrom(ITypeDescriptorContext context,CultureInfo culInfo, object value); { return baseType.ConvertFrom(context,culInfo,value); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "ConvertFrom"; cmm.ReturnType = new CodeTypeReference("System.Object"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(CultureInfoClass,CultureInfoVar)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"),ValueVar)); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"ConvertFrom"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(CultureInfoVar)); cmie.Parameters.Add(new CodeVariableReferenceExpression(ValueVar)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual object CreateInstance(ITypeDescriptorContext,IDictionary dictionary); { return baseType.CreateInstance(context,dictionary); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.ReturnType = new CodeTypeReference("System.Object"); cmm.Name = "CreateInstance"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(IDictionary,DictVar)); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"CreateInstance"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(DictVar)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual bool GetCreateInstanceSupported(ITypeDescriptorContext context); { return baseType.GetCreateInstanceSupported(context); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetCreateInstanceSupported"; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetCreateInstanceSupported"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context,object value,Attribute [] attributes); { return baseType.GetProperties(context,value); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetProperties"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"),ValueVar)); CodeTypeReference crt = new CodeTypeReference(new CodeTypeReference("System.Attribute"),1); cmm.Parameters.Add(new CodeParameterDeclarationExpression(crt,AttributeVar)); cmm.ReturnType = new CodeTypeReference(propColl); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetProperties"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(ValueVar)); cmie.Parameters.Add(new CodeVariableReferenceExpression(AttributeVar)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual GetPropertiesSupported(ITypeDescriptorContext context); { return baseType.GetPropertiesSupported(context); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetPropertiesSupported"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetPropertiesSupported"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public StandardValuesCollection virtual GetStandardValues(ITypeDescriptorContext context); { return baseType.GetStandardValues(context); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetStandardValues"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.ReturnType = new CodeTypeReference("System.ComponentModel.TypeConverter.StandardValuesCollection"); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetStandardValues"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual GetStandardValuesExclusive(ITypeDescriptorContext context); { return baseType.GetStandardValuesExclusive(context); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetStandardValuesExclusive"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetStandardValuesExclusive"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); /* public virtual GetStandardValuesSupported(ITypeDescriptorContext context); { return baseType.GetStandardValuesSupported(context); } */ cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "GetStandardValuesSupported"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"GetStandardValuesSupported"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); CodeConvertorClass.Members.Add(cmm); // if we have nullable enums we need this code /* public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType) { if ( baseType.BaseType == typeof(System.Enum) ) { if (value.GetType() == destinationType) return value; if ((value == null) && (context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return "NULL_ENUM_VALUE"; } return baseConverter.ConvertTo(context, culture, value, destinationType); } if ( (baseType == typeof(System.Boolean)) && (baseType.BaseType == typeof(System.ValueType)) ) { if ((value == null) && (context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return ""; } return baseConverter.ConvertTo(context, culture, value, destinationType); } if ((context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return ""; } return baseConverter.ConvertTo(context, culture, value, destinationType); } */ // make the member method cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded; cmm.Name = "ConvertTo"; // add the 3 parameters cmm.Parameters.Add(new CodeParameterDeclarationExpression(TypeDescriptorContextClass,contextObject)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(CultureInfoClass,CultureInfoVar)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"),ValueVar)); cmm.Parameters.Add(new CodeParameterDeclarationExpression("System.Type",TypeDstObject)); cmm.ReturnType = new CodeTypeReference("System.Object"); // make the generic return statement we'll need all over /* return baseConverter.ConvertTo(context, culture, value, destinationType); */ cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(baseTypeMemberVariable),"ConvertTo"); cmie.Parameters.Add(new CodeVariableReferenceExpression(contextObject)); cmie.Parameters.Add(new CodeVariableReferenceExpression(CultureInfoVar)); cmie.Parameters.Add(new CodeVariableReferenceExpression(ValueVar)); cmie.Parameters.Add(new CodeVariableReferenceExpression(TypeDstObject)); CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(cmie); // if ( baseType.BaseType == typeof(System.Enum) ) cis = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(typeMemberVariable), "BaseType"); cboe1.Right = new CodeTypeOfExpression(typeof(System.Enum)); cboe1.Operator = CodeBinaryOperatorType.IdentityEquality; cis.Condition = cboe1; // true statements: /* if (value.GetType() == destinationType) return value; if ((value == null) && (context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return "NULL_ENUM_VALUE"; } return baseConverter.ConvertTo(context, culture, value, destinationType); */ CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("value"),"GetType"); cboe2.Right = new CodeVariableReferenceExpression("destinationType"); cboe2.Operator = CodeBinaryOperatorType.IdentityEquality; cis.TrueStatements.Add(new CodeConditionStatement(cboe2,new CodeMethodReturnStatement(new CodeVariableReferenceExpression("value")))); // work on second true statement CodeBinaryOperatorExpression cboe3 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("value"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); CodeBinaryOperatorExpression cboe4 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(contextObject), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeBinaryOperatorExpression cboe5 = new CodeBinaryOperatorExpression(); cboe5.Left = cboe3; cboe5.Right = cboe4; cboe5.Operator = CodeBinaryOperatorType.BooleanAnd; cmie = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"PropertyDescriptor"),"ShouldSerializeValue"); cmie.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"Instance")); CodeBinaryOperatorExpression cboe6 = new CodeBinaryOperatorExpression(cmie, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); CodeBinaryOperatorExpression cboe7 = new CodeBinaryOperatorExpression(); cboe7.Left = cboe5; cboe7.Right = cboe6; cboe7.Operator = CodeBinaryOperatorType.BooleanAnd; cis.TrueStatements.Add(new CodeConditionStatement(cboe7,new CodeMethodReturnStatement(new CodeSnippetExpression(" \"NULL_ENUM_VALUE\" ")))); // add the final returnstatement cis.TrueStatements.Add(returnStatement); // add the condition statement to the method and work on the next condition section cmm.Statements.Add(cis); // if ( (baseType == typeof(System.Boolean)) && (baseType.BaseType == typeof(System.ValueType)) ) cis = new CodeConditionStatement(); cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(typeMemberVariable); cboe1.Right = new CodeTypeOfExpression (PublicNamesUsed["Boolean"].ToString()); cboe1.Operator = CodeBinaryOperatorType.IdentityEquality; cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(typeMemberVariable), "BaseType"); cboe2.Right = new CodeTypeOfExpression (PublicNamesUsed["ValueType"].ToString()); cboe2.Operator = CodeBinaryOperatorType.IdentityEquality; cboe3 = new CodeBinaryOperatorExpression(); cboe3.Left = cboe1; cboe3.Right = cboe2; cboe3.Operator = CodeBinaryOperatorType.BooleanAnd; cis.Condition = cboe3; /* true statements if ((value == null) && (context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return ""; } return baseConverter.ConvertTo(context, culture, value, destinationType); */ cboe3 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("value"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); cboe4 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(contextObject), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); cboe5 = new CodeBinaryOperatorExpression(); cboe5.Left = cboe3; cboe5.Right = cboe4; cboe5.Operator = CodeBinaryOperatorType.BooleanAnd; cmie = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"PropertyDescriptor"),"ShouldSerializeValue"); cmie.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"Instance")); cboe6 = new CodeBinaryOperatorExpression(cmie, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); cboe7 = new CodeBinaryOperatorExpression(); cboe7.Left = cboe5; cboe7.Right = cboe6; cboe7.Operator = CodeBinaryOperatorType.BooleanAnd; cis.TrueStatements.Add(new CodeConditionStatement(cboe7,new CodeMethodReturnStatement(new CodePrimitiveExpression("")))); // add the final returnstatement cis.TrueStatements.Add(returnStatement); // add the condition statement to the method and work on the next condition section cmm.Statements.Add(cis); /* if ((context != null) && (context.PropertyDescriptor.ShouldSerializeValue(context.Instance) == false)) { return ""; } return baseConverter.ConvertTo(context, culture, value, destinationType); */ cis = new CodeConditionStatement(); cboe1 = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(contextObject), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); cmie = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"PropertyDescriptor"),"ShouldSerializeValue"); cmie.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(contextObject),"Instance")); cboe2 = new CodeBinaryOperatorExpression(cmie, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); cboe3 = new CodeBinaryOperatorExpression(); cboe3.Left = cboe1; cboe3.Right = cboe2; cboe3.Operator = CodeBinaryOperatorType.BooleanAnd; cis.Condition = cboe3; cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(""))); cmm.Statements.Add(cis); // add the extra return at the end cmm.Statements.Add(returnStatement); CodeConvertorClass.Members.Add(cmm); CodeConvertorClass.Comments.Add(new CodeCommentStatement(GetString("COMMENT_PROPTYPECONVERTER"))); return CodeConvertorClass; } private void GenerateCollectionClass() { string strManagementObjectCollectionType = "ManagementObjectCollection"; string strObjectCollection = "privColObj"; string strobjCollection = "objCollection"; //public class ServiceCollection : ICollection, IEnumerable ccc = new CodeTypeDeclaration(PrivateNamesUsed["CollectionClass"].ToString()); ccc.BaseTypes.Add("System.Object"); ccc.BaseTypes.Add("ICollection"); ccc.TypeAttributes =TypeAttributes.NestedPublic ; //private ManagementObjectCollection objCollection; cf = new CodeMemberField(); cf.Name = strObjectCollection; cf.Attributes = MemberAttributes.Private | MemberAttributes.Final; cf.Type = new CodeTypeReference(strManagementObjectCollectionType); ccc.Members.Add(cf); //internal ServiceCollection(ManagementObjectCollection obj) //{ // objCollection = obj; //} cctor = new CodeConstructor(); // cctor.Attributes = MemberAttributes.Assembly; cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Name = strobjCollection; cpde.Type = new CodeTypeReference(strManagementObjectCollectionType); cctor.Parameters.Add(cpde); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strObjectCollection), new CodeVariableReferenceExpression(strobjCollection))); ccc.Members.Add(cctor); //public Int32 Count { // get { // return objCollection.Count; // } //} cmp = new CodeMemberProperty(); cmp.Type = new CodeTypeReference("System.Int32"); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmp.Name = "Count"; cmp.ImplementationTypes.Add("System.Collections.ICollection"); //cmp.ImplementsType = "ICollection"; cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(strObjectCollection), "Count"))); ccc.Members.Add(cmp); //public bool IsSynchronized { // get { // return objCollection.IsSynchronized; // } //} cmp = new CodeMemberProperty(); cmp.Type = new CodeTypeReference("System.Boolean"); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmp.Name = "IsSynchronized"; cmp.ImplementationTypes.Add("System.Collections.ICollection"); //cmp.ImplementsType = "ICollection"; cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(strObjectCollection), "IsSynchronized"))); ccc.Members.Add(cmp); //public Object SyncRoot { // get { // return this; // } //} cmp = new CodeMemberProperty(); cmp.Type = new CodeTypeReference("System.Object"); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmp.Name = "SyncRoot"; cmp.ImplementationTypes.Add("System.Collections.ICollection"); //cmp.ImplementsType = "ICollection"; cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodeThisReferenceExpression())); ccc.Members.Add(cmp); //public void CopyTo (Array array, Int32 index) //{ // objCollection.CopyTo(array,index); // for(int iCtr=0;iCtr < array.Length ;iCtr++) // { // array.SetValue(new Service((ManagementObject)array.GetValue(iCtr)),iCtr); // } //} string strArray = "array"; string strIndex = "index"; string strnCtr = "nCtr"; cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmm.Name = "CopyTo"; cmm.ImplementationTypes.Add("System.Collections.ICollection"); cpde = new CodeParameterDeclarationExpression(); cpde.Name = strArray; cpde.Type = new CodeTypeReference("System.Array"); cmm.Parameters.Add(cpde); cpde = new CodeParameterDeclarationExpression(); cpde.Name = strIndex; cpde.Type = new CodeTypeReference("System.Int32"); cmm.Parameters.Add(cpde); cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strObjectCollection), "CopyTo" ); cmie.Parameters.Add(new CodeVariableReferenceExpression(strArray)); cmie.Parameters.Add(new CodeVariableReferenceExpression(strIndex)); cmm.Statements.Add(new CodeExpressionStatement(cmie)); cmm.Statements.Add(new CodeVariableDeclarationStatement("System.Int32",strnCtr)); cfls = new CodeIterationStatement(); // cfls.InitStatement = new CodeVariableDeclarationStatement("Int32",strnCtr,new CodePrimitiveExpression(0)); cfls.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr),new CodePrimitiveExpression(0)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(strnCtr); cboe.Operator = CodeBinaryOperatorType.LessThan; cboe.Right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strArray),"Length"); cfls.TestExpression = cboe; cfls.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression(strnCtr), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))); cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strArray), "SetValue"); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strArray), "GetValue", new CodeVariableReferenceExpression(strnCtr)); //cmie1.MethodName = "GetValue"; //cmie1.TargetObject = new CodeVariableReferenceExpression(strArray); //cmie1.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["GeneratedClassName"].ToString()); coce.Parameters.Add(new CodeCastExpression(new CodeTypeReference(PublicNamesUsed["LateBoundClass"].ToString()),cmie1)); cmie.Parameters.Add(coce); cmie.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); cfls.Statements.Add(new CodeExpressionStatement(cmie)); cmm.Statements.Add(cfls); ccc.Members.Add(cmm); //ServiceEnumerator GetEnumerator() //{ // return new ServiceEnumerator (objCollection.GetEnumerator()); //} cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmm.Name = "GetEnumerator"; cmm.ImplementationTypes.Add("System.Collections.IEnumerable"); // cmm.ReturnType = PrivateNamesUsed["EnumeratorClass"].ToString(); cmm.ReturnType = new CodeTypeReference("System.Collections.IEnumerator"); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["EnumeratorClass"].ToString()); coce.Parameters.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(strObjectCollection),"GetEnumerator")); cmm.Statements.Add(new CodeMethodReturnStatement(coce)); ccc.Members.Add(cmm); /* //ZINA: commenting this out for now, since //"cmm.ImplementationTypes.Add("IEnumerable");" //does not work, and therefore the function is ambiguous and //does not compile. //IEnumerator IEnumerable.GetEnumerator() //{ // return GetEnumerator (); //} cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.VTableMask; cmm.Name = "GetEnumerator"; cmm.ReturnType = new CodeTypeReference("IEnumerator"); cmm.ImplementationTypes.Add("IEnumerable"); //cmm.ImplementsType = "IEnumerable"; cmie = new CodeMethodInvokeExpression( null, //no TargetObject? "GetEnumerator" ); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); ccc.Members.Add(cmm); */ //Now generate the Enumerator Class GenerateEnumeratorClass(); ccc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_ENUMIMPL"))); cc.Members.Add(ccc); } private void GenerateEnumeratorClass() { string strObjectEnumerator = "privObjEnum"; string strManagementObjectEnumeratorType = "ManagementObjectEnumerator"; string strManagementObjectCollectionType = "ManagementObjectCollection"; string strobjEnum = "objEnum"; //public class ServiceEnumerator : IEnumerator ecc = new CodeTypeDeclaration(PrivateNamesUsed["EnumeratorClass"].ToString()); ecc.TypeAttributes =TypeAttributes.NestedPublic; ecc.BaseTypes.Add("System.Object"); ecc.BaseTypes.Add("System.Collections.IEnumerator"); //private ManagementObjectCollection.ManagementObjectEnumerator ObjectEnumerator; cf = new CodeMemberField(); cf.Name = strObjectEnumerator; cf.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cf.Type = new CodeTypeReference(strManagementObjectCollectionType+"."+ strManagementObjectEnumeratorType); ecc.Members.Add(cf); //constructor //internal ServiceEnumerator(ManagementObjectCollection.ManagementObjectEnumerator objEnum) //{ // ObjectEnumerator = objEnum; //} cctor = new CodeConstructor(); // cctor.Attributes = MemberAttributes.Assembly; cctor.Attributes = MemberAttributes.Public; cpde = new CodeParameterDeclarationExpression(); cpde.Name = strobjEnum; cpde.Type = new CodeTypeReference(strManagementObjectCollectionType + "." + strManagementObjectEnumeratorType); cctor.Parameters.Add(cpde); cctor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strObjectEnumerator), new CodeVariableReferenceExpression(strobjEnum))); ecc.Members.Add(cctor); //public Service Current { //get { // return new Service((ManagementObject)ObjectEnumerator.Current); // } //} cmp = new CodeMemberProperty(); // cmp.Type = PrivateNamesUsed["GeneratedClassName"].ToString(); cmp.Type = new CodeTypeReference("System.Object"); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmp.Name = "Current"; cmp.ImplementationTypes.Add("System.Collections.IEnumerator"); //cmp.ImplementsType = "IEnumerator"; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["GeneratedClassName"].ToString()); coce.Parameters.Add(new CodeCastExpression(new CodeTypeReference(PublicNamesUsed["LateBoundClass"].ToString()), new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(strObjectEnumerator), "Current"))); cmp.GetStatements.Add(new CodeMethodReturnStatement(coce)); ecc.Members.Add(cmp); /* //object IEnumerator.Current { //get { // return Current; // } //} cmp = new CodeMemberProperty(); cmp.Attributes = MemberAttributes.VTableMask; cmp.Type = "object"; cmp.Name = "IEnumerator.Current"; cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("Current"))); ecc.Members.Add(cmp); */ //public bool MoveNext () //{ // return ObjectEnumerator.MoveNext(); //} cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmm.Name = "MoveNext"; cmm.ImplementationTypes.Add("System.Collections.IEnumerator"); //cmm.ImplementsType = "IEnumerator"; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strObjectEnumerator), "MoveNext" ); cmm.Statements.Add(new CodeMethodReturnStatement(cmie)); ecc.Members.Add(cmm); //public void Reset () //{ // ObjectEnumerator.Reset(); //} cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Override; cmm.Name = "Reset"; cmm.ImplementationTypes.Add("System.Collections.IEnumerator"); //cmm.ImplementsType = "IEnumerator"; cmie = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(strObjectEnumerator), "Reset" ); cmm.Statements.Add(new CodeExpressionStatement (cmie)); ecc.Members.Add(cmm); ccc.Members.Add(ecc); } ////// This function will find a given string in the passed /// in a case insensitive manner and will return true if the string is found. /// int IsContainedIn(String strToFind, ref SortedList sortedList) { int nIndex = -1; for (int i=0; i < sortedList.Count; i++) { if (String.Compare(sortedList.GetByIndex(i).ToString(),strToFind,StringComparison.OrdinalIgnoreCase) == 0) { //The string is found. This is the index nIndex = i; break; } } return nIndex; } ////// This function will convert the given CIMTYPE to an acceptable .NET type. /// Since CLS doen't support lotz of the basic types, we are using .NET helper /// classes here. We safely assume that there won't be any problem using them /// since .NET has to be there for the System.Management.Dll to work. /// /// /// private CodeTypeReference ConvertCIMType(CimType cType,bool isArray) { string strType; switch(cType) { case CimType.SInt8: { strType = "System.SByte"; break; } case CimType.UInt8: // { strType = "System.Byte"; break; } case CimType.SInt16: { strType = "System.Int16"; break; } case CimType.UInt16: { if (bUnsignedSupported == false) { strType = "System.Int16"; } else { strType = "System.UInt16"; } break; } case CimType.SInt32: { strType = "System.Int32"; break; } case CimType.UInt32: { if (bUnsignedSupported == false) { strType = "System.Int32"; } else { strType = "System.UInt32"; } break; } case CimType.SInt64: { strType = "System.Int64"; break; } case CimType.UInt64: { if (bUnsignedSupported == false) { strType = "System.Int64"; } else { strType = "System.UInt64"; } break; } case CimType.Real32: { strType = "System.Single"; break; } case CimType.Real64: { strType = "System.Double"; break; } case CimType.Boolean: { strType = "System.Boolean"; break; } case CimType.String: { strType = "System.String"; break; } case CimType.DateTime: { strType = "System.DateTime"; break; } case CimType.Reference: { strType = PublicNamesUsed["PathClass"].ToString(); break; } case CimType.Char16: { strType = "System.Char"; break; } case CimType.Object: default: strType = PublicNamesUsed["BaseObjClass"].ToString(); break; } if (isArray ) { return new CodeTypeReference(strType,1); } else { return new CodeTypeReference(strType); } } ////// This function is used to determine whether the given CIMTYPE can be represented as an integer. /// This helper function is mainly used to determine whether this type will be support by enums. /// /// private static bool isTypeInt(CimType cType) { bool retVal; switch(cType) { case CimType.UInt8: // case CimType.UInt16: case CimType.UInt32: // FIXX VB code generator cannot have Long enumerators case CimType.SInt8: case CimType.SInt16: case CimType.SInt32: { retVal = true; break; } case CimType.SInt64: case CimType.UInt64: case CimType.Real32: case CimType.Real64: case CimType.Boolean: case CimType.String: case CimType.DateTime: case CimType.Reference: case CimType.Char16: case CimType.Object: default: retVal = false; break; } return retVal; } ////// public string GeneratedFileName { get { return genFileName; } } ///[To be supplied.] ////// public string GeneratedTypeName { get { return PrivateNamesUsed["GeneratedNamespace"].ToString() + "." + PrivateNamesUsed["GeneratedClassName"].ToString(); } } ///[To be supplied.] ////// Function to convert a given ValueMap or BitMap name to propert enum name /// static string ConvertValuesToName(string str) { string strRet = String.Empty; string strToReplace = "_"; string strToAdd = String.Empty; bool bAdd = true; if (str.Length == 0) { return string.Copy(""); } char[] arrString = str.ToCharArray(); // First character if (Char.IsLetter(arrString[0]) == false) { strRet = "Val_"; strToAdd = "l"; } for(int i=0;i < str.Length;i++) { bAdd = true; if (Char.IsLetterOrDigit(arrString[i]) == false) { // if the previous character added is "_" then // don't add that to the output string again if (strToAdd == strToReplace) { bAdd = false; } else { strToAdd = strToReplace; } } else { strToAdd = new string(arrString[i],1); } if (bAdd == true) { strRet = String.Concat(strRet,strToAdd); } } return strRet; } ////// This function goes thru the names in array list and resolves any duplicates /// if any so that these names can be added as values of enum /// void ResolveEnumNameValues(ArrayList arrIn,ref ArrayList arrayOut) { arrayOut.Clear(); int nCurIndex = 0; string strToAdd = String.Empty; IFormatProvider formatProv = (IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32)); for( int i = 0 ; i < arrIn.Count ; i++) { strToAdd = arrIn[i].ToString(); strToAdd = ResolveCollision(strToAdd,true); if (true == IsContainedInArray(strToAdd, arrayOut)) { nCurIndex = 0; strToAdd = arrIn[i].ToString() + nCurIndex.ToString(formatProv); while(true == IsContainedInArray(strToAdd,arrayOut)) { nCurIndex++; strToAdd = arrIn[i].ToString() + nCurIndex.ToString(formatProv); } } arrayOut.Add(strToAdd); } } ////// This function will find a given string in the passed /// array list. /// static bool IsContainedInArray(String strToFind, ArrayList arrToSearch) { for (int i=0; i < arrToSearch.Count; i++) { if (String.Compare(arrToSearch[i].ToString(),strToFind,StringComparison.OrdinalIgnoreCase) == 0) { return true; } } return false; } ////// Function to create a appropriate generator /// bool InitializeCodeGenerator(CodeLanguage lang) { string strProvider = ""; Assembly asm = null; Type codeProvType = null; bool bSucceeded = true; AssemblyName curAssemblyName = null; AssemblyName assemblyName = null; try { switch(lang) { case CodeLanguage.VB: strProvider = "Visual Basic."; cp = new VBCodeProvider(); break; case CodeLanguage.JScript: strProvider = "JScript.NET."; cp = new JScriptCodeProvider(); break; case CodeLanguage.CSharp: strProvider = "C#."; cp= new CSharpCodeProvider() ; break; case CodeLanguage.VJSharp: strProvider = "Visual J#."; bSucceeded = false; curAssemblyName = Assembly.GetExecutingAssembly().GetName(); assemblyName = new AssemblyName(); assemblyName.CultureInfo = new CultureInfo(""); assemblyName.Name = "VJSharpCodeProvider"; assemblyName.SetPublicKey(curAssemblyName.GetPublicKey()); assemblyName.Version = curAssemblyName.Version; asm = Assembly.Load(assemblyName); //asm = Assembly.LoadWithPartialName("VJSharpCodeProvider"); if(asm != null) { codeProvType = asm.GetType("Microsoft.VJSharp.VJSharpCodeProvider"); if( codeProvType != null) { cp = (System.CodeDom.Compiler.CodeDomProvider)Activator.CreateInstance(codeProvType); bSucceeded = true; } } break; case CodeLanguage.Mcpp: strProvider = "Managed C++."; bSucceeded = false; curAssemblyName = Assembly.GetExecutingAssembly().GetName(); assemblyName = new AssemblyName(); assemblyName.CultureInfo = new CultureInfo(""); assemblyName.SetPublicKey(curAssemblyName.GetPublicKey()); assemblyName.Name = "CppCodeProvider"; assemblyName.Version = new Version(VSVERSION); asm = Assembly.Load(assemblyName); if(asm != null) { codeProvType = asm.GetType("Microsoft.VisualC.CppCodeProvider"); if( codeProvType != null) { cp = (System.CodeDom.Compiler.CodeDomProvider)Activator.CreateInstance(codeProvType); bSucceeded = true; } } break; } } catch { throw new ArgumentOutOfRangeException(String.Format(GetString("UNABLE_TOCREATE_GEN_EXCEPT") , strProvider )); } if(bSucceeded == true) { GetUnsignedSupport(lang); } else { throw new ArgumentOutOfRangeException(String.Format(GetString("UNABLE_TOCREATE_GEN_EXCEPT") , strProvider)); } return true; } ////// Function which checks if the language supports Unsigned numbers /// /// Language ///true - if unsigned is supported void GetUnsignedSupport(CodeLanguage Language) { switch(Language) { case CodeLanguage.CSharp: bUnsignedSupported = true; break; case CodeLanguage.VB: case CodeLanguage.JScript: // bUnsignedSupported = false; break; default: break; } } ////// Function which adds commit function to commit all the changes /// to the object to WMI /// void GenerateCommitMethod() { cmm = new CodeMemberMethod(); cmm.Name = PublicNamesUsed["CommitMethod"].ToString(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmm.CustomAttributes = new CodeAttributeDeclarationCollection(); cmm.CustomAttributes.Add(cad); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()); cmie.Method.MethodName = "Put"; cis.TrueStatements.Add(new CodeExpressionStatement(cmie)); cmm.Statements.Add(cis); cc.Members.Add(cmm); // Adding a overloaded method for PutOptions parameter cmm = new CodeMemberMethod(); cmm.Name = PublicNamesUsed["CommitMethod"].ToString(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression(); cpde.Type = new CodeTypeReference(PublicNamesUsed["PutOptions"].ToString()); cpde.Name = PrivateNamesUsed["putOptions"].ToString(); cmm.Parameters.Add(cpde); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmm.CustomAttributes = new CodeAttributeDeclarationCollection(); cmm.CustomAttributes.Add(cad); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; cmie = new CodeMethodInvokeExpression(); cmie.Method.TargetObject = new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()); cmie.Method.MethodName = "Put"; cmie.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["putOptions"].ToString())); cis.TrueStatements.Add(new CodeExpressionStatement(cmie)); cmm.Statements.Add(cis); cc.Members.Add(cmm); } ////// Function to convert a value in format "0x..." to a integer /// to the object to WMI /// static Int32 ConvertBitMapValueToInt32(String bitMap) { String strTemp = "0x"; Int32 ret = 0; if (bitMap.StartsWith(strTemp, StringComparison.Ordinal) || bitMap.StartsWith(strTemp.ToUpper(CultureInfo.InvariantCulture), StringComparison.Ordinal)) { strTemp = String.Empty; char[] arrString = bitMap.ToCharArray(); int Len = bitMap.Length; for (int i = 2 ; i < Len ; i++) { strTemp = strTemp + arrString[i]; } ret = System.Convert.ToInt32(strTemp,(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32))); } else { ret = System.Convert.ToInt32(bitMap,(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32))); } return ret; } ////// Function to get the Converstion function to be used for Numeric datatypes /// String GetConversionFunction(CimType cimType) { String retFunctionName = String.Empty; switch(cimType) { case CimType.UInt8: retFunctionName = "ToByte"; break; case CimType.SInt8: retFunctionName = "ToSByte"; break; case CimType.SInt16: retFunctionName = "ToInt16"; break; case CimType.UInt16: if (bUnsignedSupported == false) { retFunctionName = "ToInt16"; } else { retFunctionName = "ToUInt16"; } break; case CimType.SInt32: retFunctionName = "ToInt32"; break; case CimType.UInt32: { if (bUnsignedSupported == false) { retFunctionName = "ToInt32"; } else { retFunctionName = "ToUInt32"; } break; } case CimType.SInt64: { retFunctionName = "ToInt64"; break; } case CimType.UInt64: { if (bUnsignedSupported == false) { retFunctionName = "ToInt64"; } else { retFunctionName = "ToUInt64"; } break; } case CimType.Real32: { retFunctionName = "ToSingle"; break; } case CimType.Real64: { retFunctionName = "ToDouble"; break; } case CimType.Boolean: { retFunctionName = "ToBoolean"; break; } case CimType.Char16: { retFunctionName = "ToChar"; break; } case CimType.String: { retFunctionName = "ToString"; break; } } return retFunctionName; } ////// Checks if a given property is to be visible for Designer seriliazation /// static bool IsDesignerSerializationVisibilityToBeSet(String propName) { if (String.Compare(propName,"Path",StringComparison.OrdinalIgnoreCase) != 0) { return true; } return false; } ////// Checks if the given property type is represented as ValueType /// private static bool IsPropertyValueType(CimType cType) { bool ret = true; switch(cType) { case CimType.String: case CimType.Reference: case CimType.Object: ret = false; break; } return ret; } ////// Gets the dynamic qualifier on the class to find if the /// class is a dynamic class /// private bool IsDynamicClass() { bool ret = false; try { ret = System.Convert.ToBoolean(classobj.Qualifiers["dynamic"].Value,(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Boolean))); } catch(ManagementException) { // do nothing. This may be due to dynamic qualifer not present which is equivalent // dynamic qualifier absent } return ret; } ////// Converts a numberic value to appropriate type and adds it to array /// private static string ConvertToNumericValueAndAddToArray(CimType cimType, string numericValue,ArrayList arrayToAdd,out string enumType) { string retFunctionName = String.Empty; enumType = String.Empty; switch(cimType) { case CimType.UInt8: case CimType.SInt8: case CimType.SInt16: case CimType.UInt16: case CimType.SInt32: arrayToAdd.Add(System.Convert.ToInt32(numericValue,(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32)))); retFunctionName = "ToInt32"; enumType = "System.Int32"; break; case CimType.UInt32: arrayToAdd.Add(System.Convert.ToInt32(numericValue,(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.Int32)))); retFunctionName = "ToInt32"; enumType = "System.Int32"; break; } return retFunctionName; } /* ////// Function to initialize the comments to be put in the generated code /// Later can be moved to Resource once resource for System.management.dll is setup /// private void InitializeComments() { string strComment = "Functions ShouldSerializeare functions used by VS property browser to check if"; strComment = strComment + " a particular property has to be serialized. These functions are added for all ValueType"; strComment = strComment + " properties ( properties of type Int32, BOOL etc.. which cannot be set to null). These functions"; strComment = strComment + " uses Is Null function. These functions are also used in the TypeConverter implementation"; strComment = strComment + " for the properties to check for NULL value of property so that a empty value can be shown"; strComment = strComment + " in Property browser in case of Drag and Drop in Visual studio."; CommentsString.Add(strComment); // IDS_COMMENT_SHOULDSERIALIZE strComment = "Functions Is Null() are functions . These functions are to be used to check if a property is NULL."; CommentsString.Add(strComment); // IDS_COMMENT_ISPROPNULL strComment = "Functions Reset are added for Nullable Read/Write properties. These functions are used in VS designere in"; strComment = strComment + " property browser to set a property to NULL."; CommentsString.Add(strComment); // IDS_COMMENT_RESETPROP strComment = "Every property added to the class for WMI property has attributes set to define its behaviour in Visual Studio"; strComment = strComment + " designer and as well as to define a TypeConverter to be used."; CommentsString.Add(strComment); // IDS_COMMENT_ATTRIBPROP strComment = "DateTime Conversions are added for the class to convert DMTF date to System.DateTime and Vise-versa. Conversion from DMTF"; strComment = strComment + " to System.DateTime conversion ignores the microseconds as System.DateTime doesn't have the microseconds part in it."; CommentsString.Add(strComment); // IDS_COMMENT_DATECONVFUNC strComment = "Different flavours of GetInstances() help in enumerating instances of the WMI class."; CommentsString.Add(strComment); // IDS_COMMENT_GETINSTANCES strComment = "An Early Bound class generated for the WMI class "; CommentsString.Add(strComment); // IDS_COMMENT_CLASSBEGIN CommentsString.Add("Member variable to store the autocommit behaviour for the class"); // IDS_COMMENT_PRIV_AUTOCOMMIT CommentsString.Add("Below are different flavours of constructors to initialize the instance with a WMI object"); // IDS_COMMENT_CONSTRUCTORS CommentsString.Add("Property returns the namespace of the WMI class"); // IDS_COMMENT_[....]_NAMESPACE CommentsString.Add("Name of the WMI class"); // IDS_COMMENT_CLASSNAME; CommentsString.Add("Property pointing to a embeded object to get System properties of the WMI object"); // IDS_COMMENT_SYSOBJECT CommentsString.Add("Underlying lateBound WMI object"); // IDS_COMMENT_LATEBOUNDOBJ CommentsString.Add(" ManagementScope of the object"); // IDS_COMMENT_MGMTSCOPE strComment = "Property to show the autocommit behaviour for the WMI object. If this is"; strComment = strComment + "true then WMI object is saved to WMI then for change in every"; strComment = strComment + "property (ie Put is called after modification of a property) "; CommentsString.Add(strComment); // IDS_COMMENT_AUTOCOMMITPROP CommentsString.Add("The ManagementPath of the underlying WMI object"); // IDS_COMMENT_MGMTPATH CommentsString.Add("TypeConverter to handle null values for ValueType properties"); // IDS_COMMENT_PROP_TYPECONVERTER CommentsString.Add(" Embedded class to represent WMI system Properties"); // IDS_COMMENT_SYSPROPCLASS CommentsString.Add("Enumerator implementation for enumerating instances of the class"); // IDS_COMMENT_ENUMIMPL CommentsString.Add("Property returning the underlying lateBound object"); // IDS_COMMENT_LATEBOUNDPROP CommentsString.Add("Private property to hold the name of WMI class which created this class"); // IDS_COMMENTS_CREATEDCLASS CommentsString.Add("Private variable to hold the embedded property representing the instance"); // IDS_COMMENT_EMBEDDEDOBJ CommentsString.Add("The current WMI object used"); //IDS_COMMENT_CURRENTOBJ CommentsString.Add("Flag to indicate if an instance is an embedded object"); // IDS_COMMENT_FLAGFOREMBEDDED } */ /// /// Adds comments at the begining of the class defination /// void AddClassComments(CodeTypeDeclaration cc) { cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_SHOULDSERIALIZE"))); cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_ISPROPNULL"))); cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_RESETPROP"))); cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_ATTRIBPROP"))); } ////// Stub function to get a particular string by ID. /// Later can be replaced by a a function call to get string /// from string resource /// static string GetString(string strToGet) { return RC.GetString(strToGet); } ////// Generates code for ManagementClassName Property /// private void GenerateClassNameProperty() { string strRetVar = "strRet"; cmp = new CodeMemberProperty (); cmp.Name = PublicNamesUsed["ClassNameProperty"].ToString(); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cmp.Type = new CodeTypeReference("System.String"); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); caa = new CodeAttributeArgument(); caa.Value = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DesignerSerializationVisibility"),"Hidden"); cad = new CodeAttributeDeclaration(); cad.Name = "DesignerSerializationVisibility"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); cmp.GetStatements.Add (new CodeVariableDeclarationStatement("System.String",strRetVar, new CodeVariableReferenceExpression(PrivateNamesUsed["CreationClassName"].ToString()))); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis.Condition = cboe; CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), PublicNamesUsed["ClassPathProperty"].ToString()); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; cis1.Condition = cboe1; cis.TrueStatements.Add(cis1); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strRetVar), new CodeCastExpression(new CodeTypeReference("System.String"), new CodeIndexerExpression(new CodeVariableReferenceExpression(PrivateNamesUsed["CurrentObject"].ToString()), new CodePrimitiveExpression("__CLASS"))))); CodeConditionStatement cis2 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe3 = new CodeBinaryOperatorExpression(); cboe3.Left = new CodeVariableReferenceExpression(strRetVar); cboe3.Right = new CodePrimitiveExpression(null); cboe3.Operator = CodeBinaryOperatorType.IdentityEquality; CodeBinaryOperatorExpression cboe4 = new CodeBinaryOperatorExpression(); cboe4.Left = new CodeVariableReferenceExpression(strRetVar); cboe4.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.String"),"Empty"); cboe4.Operator = CodeBinaryOperatorType.IdentityEquality; CodeBinaryOperatorExpression cboe5 = new CodeBinaryOperatorExpression(); cboe5.Left = cboe3; cboe5.Right = cboe4; cboe5.Operator = CodeBinaryOperatorType.BooleanOr; cis2.Condition = cboe5; cis2.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strRetVar), new CodeVariableReferenceExpression(PrivateNamesUsed["CreationClassName"].ToString()))); cis1.TrueStatements.Add(cis2); cmp.GetStatements.Add(cis); cmp.GetStatements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression(strRetVar))); cc.Members.Add (cmp); } ////// Generates the functions CheckIfProperClass() which checks if the given path /// can be represented with the generated code /// void GenerateIfClassvalidFuncWithAllParams() { string strPathParam = "path"; string strGetOptions = "OptionsParam"; cmm = new CodeMemberMethod (); cmm.Name = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmm.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()),PrivateNamesUsed["ScopeParam"].ToString())); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPathParam)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["GetOptionsClass"].ToString()),strGetOptions)); CodeExpression[] parms = new CodeExpression[] { new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strPathParam),"ClassName"), // new CodeVariableReferenceExpression(PublicNamesUsed["ClassNameProperty"].ToString()), new CodePropertyReferenceExpression(new CodeThisReferenceExpression(),PublicNamesUsed["ClassNameProperty"].ToString()), new CodePrimitiveExpression(true), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Globalization.CultureInfo"),"InvariantCulture") }; cmie = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("System.String"), "Compare", parms ); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(strPathParam); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cboe1; cboe2.Right = cboe; cboe2.Operator = CodeBinaryOperatorType.BooleanAnd; cis = new CodeConditionStatement(); cis.Condition = cboe2; cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["LateBoundClass"].ToString()); coce.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["ScopeParam"].ToString())); coce.Parameters.Add(new CodeVariableReferenceExpression(strPathParam)); coce.Parameters.Add(new CodeVariableReferenceExpression(strGetOptions)); CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(); cmre.MethodName = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(cmre,coce))); cmm.Statements.Add(cis); // cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false))); cc.Members.Add(cmm); } ////// Generates the functions CheckIfProperClass() which checks if the given path /// can be represented with the generated code /// void GenerateIfClassvalidFunction() { // Call this function to generate the first overload of this function GenerateIfClassvalidFuncWithAllParams(); string strTempObj = "theObj"; string strnCtr = "count"; string strDerivation = "parentClasses"; cmm = new CodeMemberMethod (); cmm.Name = PrivateNamesUsed["ClassNameCheckFunc"].ToString(); cmm.Attributes = MemberAttributes.Private | MemberAttributes.Final ; cmm.ReturnType = new CodeTypeReference("System.Boolean"); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(PublicNamesUsed["BaseObjClass"].ToString()),strTempObj)); CodeExpression[] parms = new CodeExpression[] { new CodeCastExpression(new CodeTypeReference("System.String"), new CodeIndexerExpression(new CodeVariableReferenceExpression(strTempObj), new CodePrimitiveExpression("__CLASS"))), new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), PublicNamesUsed["ClassNameProperty"].ToString()), new CodePrimitiveExpression(true), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Globalization.CultureInfo"),"InvariantCulture") }; cmie = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("System.String"), "Compare", parms ); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(strTempObj); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cboe1; cboe2.Right = cboe; cboe2.Operator = CodeBinaryOperatorType.BooleanAnd; cis = new CodeConditionStatement(); cis.Condition = cboe2; cis.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); CodeExpression cs = new CodeCastExpression(new CodeTypeReference("System.Array"), new CodeIndexerExpression(new CodeVariableReferenceExpression(strTempObj), new CodePrimitiveExpression("__DERIVATION"))); cis.FalseStatements.Add(new CodeVariableDeclarationStatement("System.Array",strDerivation,cs)); CodeConditionStatement cis1 = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(strDerivation); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis1.Condition = cboe; cfls = new CodeIterationStatement(); cis1.TrueStatements.Add(new CodeVariableDeclarationStatement("System.Int32",strnCtr,new CodePrimitiveExpression(0))); cfls.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr),new CodePrimitiveExpression(0)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(strnCtr); cboe.Operator = CodeBinaryOperatorType.LessThan; cboe.Right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strDerivation),"Length"); cfls.TestExpression = cboe; cfls.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression(strnCtr), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "GetValue"; cmie1.Method.TargetObject = new CodeVariableReferenceExpression(strDerivation); cmie1.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); CodeExpression[] parms1 = new CodeExpression[] { new CodeCastExpression(new CodeTypeReference("System.String"),cmie1), new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), PublicNamesUsed["ClassNameProperty"].ToString()), new CodePrimitiveExpression(true), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Globalization.CultureInfo"),"InvariantCulture") }; CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("System.String"), "Compare", parms1); CodeConditionStatement cis2 = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie2; cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis2.Condition = cboe; cis2.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); cis1.TrueStatements.Add(cfls); cfls.Statements.Add(cis2); cis.FalseStatements.Add(cis1); cmm.Statements.Add(cis); cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false))); cc.Members.Add(cmm); } ////// Generates code for Property Get for Cimtype.Reference and CimType.DateTime type property /// Also generated code to initialize a variable after converting a property to DateTime and ManagementPathProperty /// void GenerateCodeForRefAndDateTimeTypes(CodeIndexerExpression prop,bool bArray,CodeStatementCollection statColl,string strType,CodeVariableReferenceExpression varToAssign,bool bIsValueProprequired) { if(bArray == false) { CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = prop; cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; cboe1.Right = new CodePrimitiveExpression(null); cis1.Condition = cboe1; // if the type is string then check for null is to be done // otherwise, the DateTime Conversion function will do for DateTime types if(String.Compare(strType,PublicNamesUsed["PathClass"].ToString(),StringComparison.OrdinalIgnoreCase) == 0) { CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(); cmre.MethodName = "ToString"; cmre.TargetObject = prop; cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; if(varToAssign == null) { cis1.TrueStatements.Add (new CodeMethodReturnStatement(CreateObjectForProperty(strType,cmie))); statColl.Add(cis1); statColl.Add (new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); } else { // Assign null to variable statColl.Add(new CodeAssignStatement(varToAssign,new CodePrimitiveExpression(null))); cis1.TrueStatements.Add (new CodeAssignStatement(varToAssign ,CreateObjectForProperty(strType,cmie))); statColl.Add(cis1); } } else { statColl.Add(cis1); CodeExpression ce = null; if(bIsValueProprequired) { ce = new CodeCastExpression(new CodeTypeReference("System.String"),new CodePropertyReferenceExpression(prop,"Value")); } else { ce = new CodeCastExpression(new CodeTypeReference("System.String"),prop); } if(varToAssign == null) { cis1.TrueStatements.Add(new CodeMethodReturnStatement(CreateObjectForProperty(strType,ce))); cis1.FalseStatements.Add(new CodeMethodReturnStatement(CreateObjectForProperty(strType,null))); } else { cis1.TrueStatements.Add(new CodeAssignStatement(varToAssign,CreateObjectForProperty(strType,ce))); cis1.FalseStatements.Add(new CodeAssignStatement(varToAssign,CreateObjectForProperty(strType,null))); } } } else { string strLength = "len"; string strnCtr = "iCounter"; string strArray = "arrToRet"; CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = prop; cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; cboe1.Right = new CodePrimitiveExpression(null); cis1.Condition = cboe1; CodePropertyReferenceExpression LenProp = null; if(bIsValueProprequired == true) { LenProp = new CodePropertyReferenceExpression( new CodeCastExpression( new CodeTypeReference("System.Array"), new CodePropertyReferenceExpression(prop,"Value") ), "Length" ); } else { LenProp = new CodePropertyReferenceExpression( new CodeCastExpression( new CodeTypeReference("System.Array"), prop ), "Length" ); } cis1.TrueStatements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int32"), strLength, LenProp ) ); CodeTypeReference arrPathType = new CodeTypeReference( new CodeTypeReference(strType), 1 ); cis1.TrueStatements.Add( new CodeVariableDeclarationStatement( arrPathType, strArray, new CodeArrayCreateExpression( new CodeTypeReference(strType), new CodeVariableReferenceExpression(strLength) ) ) ); cfls = new CodeIterationStatement(); cfls.InitStatement = new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int32"), strnCtr, new CodePrimitiveExpression(0) ); cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(strnCtr); cboe1.Operator = CodeBinaryOperatorType.LessThan; cboe1.Right = new CodeVariableReferenceExpression(strLength); cfls.TestExpression = cboe1; cfls.IncrementStatement = new CodeAssignStatement( new CodeVariableReferenceExpression(strnCtr), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression(strnCtr), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1) ) ); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "GetValue"; if(bIsValueProprequired == true) { cmie1.Method.TargetObject = new CodeCastExpression(new CodeTypeReference("System.Array"),new CodePropertyReferenceExpression(prop,"Value")); } else { cmie1.Method.TargetObject = new CodeCastExpression(new CodeTypeReference("System.Array"), prop); } cmie1.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method.MethodName = "ToString"; cmie2.Method.TargetObject = cmie1; cfls.Statements.Add( new CodeAssignStatement(new CodeIndexerExpression(new CodeVariableReferenceExpression(strArray), new CodeVariableReferenceExpression(strnCtr)),CreateObjectForProperty(strType,cmie2))); cis1.TrueStatements.Add(cfls); if(varToAssign == null) { cis1.TrueStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(strArray))); statColl.Add (cis1); statColl.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); } else { // Assign null to variable statColl.Add(new CodeAssignStatement(varToAssign,new CodePrimitiveExpression(null))); cis1.TrueStatements.Add(new CodeAssignStatement(varToAssign ,new CodeVariableReferenceExpression(strArray))); statColl.Add (cis1); } } } ////// Generates code for Property Set for Cimtype.DateTime and CimType.Reference type property /// void AddPropertySet(CodeIndexerExpression prop,bool bArray,CodeStatementCollection statColl,string strType,CodeVariableReferenceExpression varValue) { if(varValue == null) { varValue = new CodeVariableReferenceExpression("value"); } if(bArray == false) { statColl.Add(new CodeAssignStatement(prop, ConvertPropertyToString(strType, varValue))); } else { string strLength = "len"; string strnCtr = "iCounter"; string strArray = "arrProp"; CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = varValue; cboe1.Operator = CodeBinaryOperatorType.IdentityInequality; cboe1.Right = new CodePrimitiveExpression(null); cis1.Condition = cboe1; CodePropertyReferenceExpression LenProp = new CodePropertyReferenceExpression( new CodeCastExpression( new CodeTypeReference("System.Array"), varValue ), "Length" ); cis1.TrueStatements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int32"), strLength, LenProp ) ); CodeTypeReference arrPathType = new CodeTypeReference(new CodeTypeReference("System.String"), 1); cis1.TrueStatements.Add( new CodeVariableDeclarationStatement( arrPathType, strArray, new CodeArrayCreateExpression( new CodeTypeReference("System.String"), new CodeVariableReferenceExpression(strLength) ) ) ); cfls = new CodeIterationStatement(); cfls.InitStatement = new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int32"), strnCtr, new CodePrimitiveExpression(0) ); cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(strnCtr); cboe1.Operator = CodeBinaryOperatorType.LessThan; cboe1.Right = new CodeVariableReferenceExpression(strLength); cfls.TestExpression = cboe1; cfls.IncrementStatement = new CodeAssignStatement( new CodeVariableReferenceExpression(strnCtr), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression(strnCtr), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1) ) ); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "GetValue"; cmie1.Method.TargetObject = new CodeCastExpression(new CodeTypeReference("System.Array"),varValue); cmie1.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); cfls.Statements.Add( new CodeAssignStatement(new CodeIndexerExpression(new CodeVariableReferenceExpression(strArray), new CodeVariableReferenceExpression(strnCtr)),ConvertPropertyToString(strType,cmie1))); cis1.TrueStatements.Add(cfls); cis1.TrueStatements.Add(new CodeAssignStatement(prop,new CodeVariableReferenceExpression(strArray))); cis1.FalseStatements.Add(new CodeAssignStatement(prop,new CodePrimitiveExpression(null))); statColl.Add (cis1); } } ////// Internal function used to create object. Used in adding code for Property Get for DateTime and Reference properties /// CodeExpression CreateObjectForProperty(string strType, CodeExpression param) { switch(strType) { case "System.DateTime" : if(param == null) { return new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"); } else { cmie = new CodeMethodInvokeExpression(); // cmie.Method.TargetObject = new CodeVariableReferenceExpression(PublicNamesUsed["DateConverter"].ToString()); cmie.Parameters.Add(param); cmie.Method.MethodName = PrivateNamesUsed["ToDateTimeMethod"].ToString(); return cmie; } case "System.TimeSpan" : if(param == null) { coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); coce.Parameters.Add(new CodePrimitiveExpression(0)); return coce; //new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("System.TimeSpan"),"MinValue"); } else { cmie = new CodeMethodInvokeExpression(); // cmie.Method.TargetObject = new CodeVariableReferenceExpression(PublicNamesUsed["DateConverter"].ToString()); cmie.Parameters.Add(param); cmie.Method.MethodName = PrivateNamesUsed["ToTimeSpanMethod"].ToString(); return cmie; } case "System.Management.ManagementPath": coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); coce.Parameters.Add(param); return coce; } return null; } ////// Internal function used to create code to convert DateTime or ManagementPath to String /// convert a expression. Used in adding code for Property Set for DateTime and Reference properties /// CodeExpression ConvertPropertyToString(string strType,CodeExpression beginingExpression) { switch(strType) { case "System.DateTime" : CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Parameters.Add(new CodeCastExpression(new CodeTypeReference("System.DateTime"),beginingExpression)); // cmie1.Method.TargetObject = new CodeVariableReferenceExpression(PublicNamesUsed["DateConverter"].ToString()); cmie1.Method.MethodName = PrivateNamesUsed["ToDMTFDateTimeMethod"].ToString(); return cmie1; case "System.TimeSpan" : CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Parameters.Add(new CodeCastExpression(new CodeTypeReference("System.TimeSpan"),beginingExpression)); // cmie2.Method.TargetObject = new CodeVariableReferenceExpression(PublicNamesUsed["DateConverter"].ToString()); cmie2.Method.MethodName = PrivateNamesUsed["ToDMTFTimeIntervalMethod"].ToString(); return cmie2; case "System.Management.ManagementPath": return new CodePropertyReferenceExpression(new CodeCastExpression( new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()), beginingExpression),PublicNamesUsed["PathProperty"].ToString()); } return null; } private void GenerateScopeProperty() { cmp = new CodeMemberProperty(); cmp.Name = PublicNamesUsed["ScopeProperty"].ToString(); cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmp.Type = new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmp.CustomAttributes = new CodeAttributeDeclarationCollection(); cmp.CustomAttributes.Add(cad); // If the property is not Path then add an attribb DesignerSerializationVisibility // to indicate that the property is to be hidden for designer serilization. if (IsDesignerSerializationVisibilityToBeSet(PublicNamesUsed["ScopeProperty"].ToString())) { caa = new CodeAttributeArgument(); caa.Value = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DesignerSerializationVisibility"),"Hidden"); cad = new CodeAttributeDeclaration(); cad.Name = "DesignerSerializationVisibility"; cad.Arguments.Add(caa); cmp.CustomAttributes.Add(cad); } cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; CodeExpression Value = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()),"Scope"); cis.TrueStatements.Add(new CodeMethodReturnStatement(Value)); cis.FalseStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); cmp.GetStatements.Add(cis); cis = new CodeConditionStatement(); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()); cboe.Right = new CodePrimitiveExpression(false); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis.Condition = cboe; cis.TrueStatements.Add(new CodeAssignStatement(Value, new CodeSnippetExpression("value"))); cmp.SetStatements.Add(cis); cc.Members.Add(cmp); cmp.Comments.Add(new CodeCommentStatement(GetString("COMMENT_MGMTSCOPE"))); } void AddGetStatementsForEnumArray(CodeIndexerExpression ciProp,CodeMemberProperty cmProp) { string strArray = "arrEnumVals"; string ArrToRet = "enumToRet"; string strnCtr = "counter"; string strEnumName = cmProp.Type.BaseType; cmProp.GetStatements.Add(new CodeVariableDeclarationStatement("System.Array",strArray, new CodeCastExpression(new CodeTypeReference("System.Array"),ciProp))); cmProp.GetStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(strEnumName,1),ArrToRet, new CodeArrayCreateExpression(new CodeTypeReference(strEnumName), new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(strArray),"Length")))); cfls = new CodeIterationStatement(); cmProp.GetStatements.Add(new CodeVariableDeclarationStatement("System.Int32",strnCtr,new CodePrimitiveExpression(0))); cfls.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr),new CodePrimitiveExpression(0)); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(strnCtr); cboe1.Operator = CodeBinaryOperatorType.LessThan; cboe1.Right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strArray),"Length"); cfls.TestExpression = cboe1; cfls.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(strnCtr), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression(strnCtr), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "GetValue"; cmie1.Method.TargetObject = new CodeVariableReferenceExpression(strArray); cmie1.Parameters.Add(new CodeVariableReferenceExpression(strnCtr)); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method.TargetObject = new CodeTypeReferenceExpression("System.Convert"); cmie2.Parameters.Add(cmie1); cmie2.Method.MethodName = arrConvFuncName; cfls.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression(new CodeVariableReferenceExpression(ArrToRet), new CodeVariableReferenceExpression(strnCtr)), new CodeCastExpression(new CodeTypeReference(strEnumName),cmie2 ))); cmProp.GetStatements.Add(cfls); cmProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(ArrToRet))); } private void AddCommentsForEmbeddedProperties() { cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT1"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT2"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT3"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT4"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT5"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT6"))); cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT7"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP1"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP2"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP3"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP4"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP5"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP6"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP7"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP8"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP9"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_VB_CODESAMP10"))); cc.Comments.Add(new CodeCommentStatement(GetString(""))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDDED_COMMENT8"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP1"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP2"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP3"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP4"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP5"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP6"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP7"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP8"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP9"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP10"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP11"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP12"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP13"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP14"))); cc.Comments.Add(new CodeCommentStatement(GetString("EMBEDED_CS_CODESAMP15"))); } // This function checks the "SubType" Qualifier and if the value of this qualifies // is "interval" then the returned CodeTypeReference is of type System.TimeSpan // otherwise the returned type will be System.DateTime. // This functions is called only for cimtype.DateTime type properties private bool GetDateTimeType(PropertyData prop,ref CodeTypeReference codeType ) { bool isTimeInterval = false; codeType = null; if(prop.IsArray) { codeType = new CodeTypeReference("System.DateTime",1); } else { codeType = new CodeTypeReference("System.DateTime"); } try { if(String.Compare(prop.Qualifiers["SubType"].Value.ToString() ,"interval",StringComparison.OrdinalIgnoreCase) == 0) { isTimeInterval = true; if(prop.IsArray) { codeType = new CodeTypeReference("System.TimeSpan",1); } else { codeType = new CodeTypeReference("System.TimeSpan"); } } } catch(ManagementException) { // Qualifier may not be present then ignore it } if(isTimeInterval) { if(bTimeSpanConversionFunctionsAdded == false) { cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TIMESPANCONVFUNC"))); bTimeSpanConversionFunctionsAdded = true; // Call this function to generate conversion function GenerateTimeSpanConversionFunction(); } } else { if(bDateConversionFunctionsAdded == false) { cc.Comments.Add(new CodeCommentStatement(GetString("COMMENT_DATECONVFUNC"))); bDateConversionFunctionsAdded = true; // Call this function to generate conversion function GenerateDateTimeConversionFunction(); } } return isTimeInterval; } ////// This function generates static CreateInstance to create an WMI instance. /// public static GenClass CreateInstance() { /// return new GenClass(new ManagementClass(new System.Management.ManagementClass(CreatedWmiNamespace, CreatedClassName, null).CreateInstance())); /// } /// void GenerateCreateInstance() { string strTemp = "tmpMgmtClass"; cmm = new CodeMemberMethod(); string strScope = "mgmtScope"; string strPath = "mgmtPath"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static ; cmm.Name = PublicNamesUsed["CreateInst"].ToString(); cmm.ReturnType = new CodeTypeReference(PrivateNamesUsed["GeneratedClassName"].ToString()); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmm.CustomAttributes = new CodeAttributeDeclarationCollection(); cmm.CustomAttributes.Add(cad); cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()), strScope, new CodePrimitiveExpression(null))); CodeConditionStatement cis1 = new CodeConditionStatement(); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()); cboe1.Right = new CodePrimitiveExpression(null); cboe1.Operator = CodeBinaryOperatorType.IdentityEquality; cis1.Condition = cboe1; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PublicNamesUsed["ScopeClass"].ToString()); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strScope),coce)); cis1.TrueStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strScope), "Path"),"NamespacePath"), new CodeVariableReferenceExpression(PrivateNamesUsed["CreationWmiNamespace"].ToString()))); cis1.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strScope), new CodeVariableReferenceExpression(PrivateNamesUsed["statMgmtScope"].ToString()))); cmm.Statements.Add(cis1); CodeObjectCreateExpression cocePath = new CodeObjectCreateExpression(); cocePath.CreateType = new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()); cocePath.Parameters.Add(new CodeVariableReferenceExpression(PrivateNamesUsed["CreationClassName"].ToString())); cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(PublicNamesUsed["PathClass"].ToString()),strPath,cocePath)); CodeObjectCreateExpression coce1 = new CodeObjectCreateExpression(); coce1.CreateType = new CodeTypeReference(PublicNamesUsed["ManagementClass"].ToString()); coce1.Parameters.Add(new CodeVariableReferenceExpression(strScope)); coce1.Parameters.Add(new CodeVariableReferenceExpression(strPath)); coce1.Parameters.Add(new CodePrimitiveExpression(null)); cmm.Statements.Add(new CodeVariableDeclarationStatement(PublicNamesUsed["ManagementClass"].ToString(),strTemp,coce1)); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "CreateInstance"; cmie1.Method.TargetObject = new CodeVariableReferenceExpression(strTemp); coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference(PrivateNamesUsed["GeneratedClassName"].ToString()); coce.Parameters.Add(cmie1); cmm.Statements.Add(new CodeMethodReturnStatement(coce)); cc.Members.Add(cmm); } ////// This function generates static CreateInstance to create an WMI instance. /// public static GenClass CreateInstance() { /// PrivateLateBoundObject.Delete(); /// } /// void GenerateDeleteInstance() { cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cmm.Name = PublicNamesUsed["DeleteInst"].ToString(); caa = new CodeAttributeArgument(); caa.Value = new CodePrimitiveExpression(true); cad = new CodeAttributeDeclaration(); cad.Name = "Browsable"; cad.Arguments.Add(caa); cmm.CustomAttributes = new CodeAttributeDeclarationCollection(); cmm.CustomAttributes.Add(cad); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method.MethodName = "Delete"; cmie1.Method.TargetObject = new CodeVariableReferenceExpression(PrivateNamesUsed["LateBoundObject"].ToString()); cmm.Statements.Add(cmie1); cc.Members.Add(cmm); } ////// Function to genreate helper function for DMTF to DateTime and DateTime to DMTF /// void GenerateDateTimeConversionFunction() { AddToDateTimeFunction(); AddToDMTFDateTimeFunction(); } ////// Function to genreate helper function for DMTF Time interval to TimeSpan and vice versa /// void GenerateTimeSpanConversionFunction() { AddToTimeSpanFunction(); AddToDMTFTimeIntervalFunction(); } ////// Generated code for function to do conversion of date from DMTF format to DateTime format /// void AddToDateTimeFunction() { String dmtfParam = "dmtfDate"; String year = "year"; String month = "month"; String day = "day"; String hour = "hour"; String minute = "minute"; String second = "second"; String ticks = "ticks"; String dmtf = "dmtf"; String tempStr = "tempString"; String datetimeVariable = "datetime"; CodeCastExpression cast = null; CodeMemberMethod cmmdt = new CodeMemberMethod(); cmmdt.Name = PrivateNamesUsed["ToDateTimeMethod"].ToString(); cmmdt.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmdt.ReturnType = new CodeTypeReference("System.DateTime"); cmmdt.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.String"),dmtfParam)); cmmdt.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TODATETIME"))); // create a local variable to initialize from - fixed warnings in MCPP which doesn't // like you copying sub items (like year) out of MinValue cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.DateTime"),"initializer",new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"))); CodeVariableReferenceExpression cvreInitializer = new CodeVariableReferenceExpression("initializer"); //Int32 year = initializer.Year; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),year,new CodePropertyReferenceExpression(cvreInitializer,"Year"))); //Int32 month = initializer.Month; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),month, new CodePropertyReferenceExpression(cvreInitializer,"Month"))); //Int32 day = initializer.Day; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),day,new CodePropertyReferenceExpression(cvreInitializer,"Day"))); //Int32 hour = initializer.Hour; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),hour,new CodePropertyReferenceExpression(cvreInitializer,"Hour"))); //Int32 minute = Sinitializer.Minute; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),minute,new CodePropertyReferenceExpression(cvreInitializer,"Minute"))); //Int32 second = initializer.Second; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),second,new CodePropertyReferenceExpression(cvreInitializer,"Second"))); //Int32 millisec = 0; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int64"),ticks,new CodePrimitiveExpression(0))); //String dmtf = dmtfDate ; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),dmtf,new CodeVariableReferenceExpression(dmtfParam))); //System.DateTime datetime = System.DateTime.MinValue ; CodeFieldReferenceExpression cpreMinVal = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"); cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.DateTime"),datetimeVariable,cpreMinVal)); //String tempString = String.Empty ; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),tempStr,new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("System.String"),"Empty"))); /* if (dmtf == null) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(dmtf); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; CodeObjectCreateExpression codeThrowException = new CodeObjectCreateExpression(); codeThrowException.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); /* if (dmtf.Length == 0) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Length"); cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); /* if (str.Length != DMTF_DATETIME_STR_LENGTH ) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Length"); cboe.Right = new CodePrimitiveExpression(DMTF_DATETIME_STR_LENGTH); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); CodeTryCatchFinallyStatement tryblock = new CodeTryCatchFinallyStatement(); DateTimeConversionFunctionHelper(tryblock.TryStatements,"****",tempStr,dmtf,year,0,4); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,month,4,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,day,6,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,hour,8,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,minute,10,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,second,12,2); /* tempString = dmtf.Substring(15, 6); if (("******" != tempString)) { ticks = (System.Int64.Parse(tempString)) * (System.TimeSpan.TicksPerMillisecond/1000); } */ CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(15)); cmie.Parameters.Add(new CodePrimitiveExpression(6)); tryblock.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePrimitiveExpression("******"); cboe.Right = new CodeVariableReferenceExpression(tempStr); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; CodeMethodReferenceExpression cmre1 = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int64"),"Parse"); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre1; cmie1.Parameters.Add(new CodeVariableReferenceExpression(tempStr)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMillisecond"); cboe.Right = new CodePrimitiveExpression(1000); cboe.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe); CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cmie1; cboe2.Right = cast; cboe2.Operator = CodeBinaryOperatorType.Multiply; cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(ticks),cboe2)); tryblock.TryStatements.Add(cis); /* if( year < 0 || month < 0 || day < 0 || hour < 0 || minute < 0 || second < 0 || ticks < 0) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboeYear = new CodeBinaryOperatorExpression(); cboeYear.Left = new CodeVariableReferenceExpression(year); cboeYear.Right = new CodePrimitiveExpression(0); cboeYear.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMonth = new CodeBinaryOperatorExpression(); cboeMonth.Left = new CodeVariableReferenceExpression(month); cboeMonth.Right = new CodePrimitiveExpression(0); cboeMonth.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeDay = new CodeBinaryOperatorExpression(); cboeDay.Left = new CodeVariableReferenceExpression(day); cboeDay.Right = new CodePrimitiveExpression(0); cboeDay.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeHour = new CodeBinaryOperatorExpression(); cboeHour.Left = new CodeVariableReferenceExpression(hour); cboeHour.Right = new CodePrimitiveExpression(0); cboeHour.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMinute = new CodeBinaryOperatorExpression(); cboeMinute.Left = new CodeVariableReferenceExpression(minute); cboeMinute.Right = new CodePrimitiveExpression(0); cboeMinute.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeSecond = new CodeBinaryOperatorExpression(); cboeSecond.Left = new CodeVariableReferenceExpression(second); cboeSecond.Right = new CodePrimitiveExpression(0); cboeSecond.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeTicks = new CodeBinaryOperatorExpression(); cboeTicks.Left = new CodeVariableReferenceExpression(ticks); cboeTicks.Right = new CodePrimitiveExpression(0); cboeTicks.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboetemp1 = new CodeBinaryOperatorExpression(); cboetemp1.Left = cboeYear; cboetemp1.Right = cboeMonth; cboetemp1.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp2 = new CodeBinaryOperatorExpression(); cboetemp2.Left = cboetemp1; cboetemp2.Right = cboeDay; cboetemp2.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp3 = new CodeBinaryOperatorExpression(); cboetemp3.Left = cboetemp2; cboetemp3.Right = cboeHour; cboetemp3.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp4 = new CodeBinaryOperatorExpression(); cboetemp4.Left = cboetemp3; cboetemp4.Right = cboeMinute; cboetemp4.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp5 = new CodeBinaryOperatorExpression(); cboetemp5.Left = cboetemp4; cboetemp5.Right = cboeMinute; cboetemp5.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp6 = new CodeBinaryOperatorExpression(); cboetemp6.Left = cboetemp5; cboetemp6.Right = cboeSecond; cboetemp6.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp7 = new CodeBinaryOperatorExpression(); cboetemp7.Left = cboetemp6; cboetemp7.Right = cboeTicks; cboetemp7.Operator = CodeBinaryOperatorType.BooleanOr; cis = new CodeConditionStatement(); cis.Condition = cboetemp7; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); tryblock.TryStatements.Add(cis); /* catch { throw new System.ArgumentOutOfRangeException(null, e.Message); } */ string exceptVar = "e"; CodeCatchClause catchblock = new CodeCatchClause(exceptVar); CodeObjectCreateExpression codeThrowExceptionWithArgs = new CodeObjectCreateExpression(); codeThrowExceptionWithArgs.CreateType = new CodeTypeReference (PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); codeThrowExceptionWithArgs.Parameters.Add(new CodePrimitiveExpression(null)); codeThrowExceptionWithArgs.Parameters.Add ( new CodePropertyReferenceExpression ( new CodeVariableReferenceExpression(exceptVar), "Message" ) ); catchblock.Statements.Add(new CodeThrowExceptionStatement(codeThrowExceptionWithArgs)); // // add the catch block to the try block // tryblock.CatchClauses.Add(catchblock); // // add the try block to cmmdt // cmmdt.Statements.Add(tryblock); /* datetime = new System.DateTime(year, month, day, hour, minute, second, millisec); */ coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.DateTime"); coce.Parameters.Add(new CodeVariableReferenceExpression(year)); coce.Parameters.Add(new CodeVariableReferenceExpression(month)); coce.Parameters.Add(new CodeVariableReferenceExpression(day)); coce.Parameters.Add(new CodeVariableReferenceExpression(hour)); coce.Parameters.Add(new CodeVariableReferenceExpression(minute)); coce.Parameters.Add(new CodeVariableReferenceExpression(second)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),coce)); /* datetime = datetime.AddTicks(ticks); */ CodeMethodReferenceExpression cmre2 = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(datetimeVariable),"AddTicks"); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = cmre2; cmie2.Parameters.Add(new CodeVariableReferenceExpression(ticks)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),cmie2)); /* System.TimeSpan tickOffset = System.TimeZone.CurrentTimeZone.GetUtcOffset(datetime); */ cmre1 = new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.TimeZone"),"CurrentTimeZone"), "GetUtcOffset"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre1; cmie1.Parameters.Add(new CodeVariableReferenceExpression(datetimeVariable)); String tickoffset = "tickOffset"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),tickoffset,cmie1)); /* System.Int32 UTCOffset = 0; System.Int32 OffsetToBeAdjusted = 0; long OffsetMins = tickOffset.Ticks / System.TimeSpan.TicksPerMinute; tempString = dmtf.Substring(22, 3); */ String utcOffset = "UTCOffset"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),utcOffset,new CodePrimitiveExpression(0))); String offsetAdjust = "OffsetToBeAdjusted"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),offsetAdjust,new CodePrimitiveExpression(0))); String OffsetMins = "OffsetMins"; cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tickoffset),"Ticks"); cboe.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMinute"); cboe.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe); cmmdt.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int64"), OffsetMins, cast ) ); cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(22)); cmie.Parameters.Add(new CodePrimitiveExpression(3)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); /* if (("***" != tempString1)) { tempString1 = dmtf.Substring(21, 4); try { UTCOffset = System.Int32.Parse(tempString1); } catch { throw new System.ArgumentOutOfRangeException(); } OffsetToBeAdjusted = UTCOffset-OffsetMins; // We have to substract the minutes from the time datetime = datetime.AddMinutes((System.Double)(OffsetToBeAdjusted)); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(tempStr); cboe.Right = new CodePrimitiveExpression("******"); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(21)); cmie.Parameters.Add(new CodePrimitiveExpression(4)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); CodeTryCatchFinallyStatement tryblock2 = new CodeTryCatchFinallyStatement(); cmre = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int32"),"Parse"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodeVariableReferenceExpression(tempStr)); tryblock2.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(utcOffset), cmie)); // // add the catch block // tryblock2.CatchClauses.Add(catchblock); // // add tryblock2 to cis // cis.TrueStatements.Add(tryblock2); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(OffsetMins); cboe.Right = new CodeVariableReferenceExpression(utcOffset); cboe.Operator = CodeBinaryOperatorType.Subtract; cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(offsetAdjust),new CodeCastExpression(new CodeTypeReference("System.Int32"),cboe))); cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(datetimeVariable),"AddMinutes"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodeCastExpression("System.Double",new CodeVariableReferenceExpression(offsetAdjust))); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),cmie)); cmmdt.Statements.Add(cis); /* return datetime; */ cmmdt.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(datetimeVariable))); cc.Members.Add(cmmdt); } ////// Generates some common code used in conversion function for DateTime /// static void DateTimeConversionFunctionHelper(CodeStatementCollection cmmdt , String toCompare, String tempVarName, String dmtfVarName, String toAssign, Int32 SubStringParam1, Int32 SubStringParam2) { CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtfVarName),"Substring"); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(SubStringParam1)); cmie.Parameters.Add(new CodePrimitiveExpression(SubStringParam2)); cmmdt.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempVarName), cmie)); CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePrimitiveExpression(toCompare); cboe.Right = new CodeVariableReferenceExpression(tempVarName); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; cmre = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int32"),"Parse"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodeVariableReferenceExpression(tempVarName)); cis.TrueStatements.Add( new CodeAssignStatement(new CodeVariableReferenceExpression(toAssign),cmie)); cmmdt.Add(cis); } void AddToDMTFTimeIntervalFunction() { String dmtfTimeSpan = "dmtftimespan"; String timespan = "timespan"; String tsTemp = "tsTemp"; String microsec = "microsec"; String strmicrosec = "strMicroSec"; CodeMemberMethod cmmts = new CodeMemberMethod(); cmmts.Name = PrivateNamesUsed["ToDMTFTimeIntervalMethod"].ToString(); cmmts.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmts.ReturnType = new CodeTypeReference("System.String"); cmmts.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.TimeSpan"),timespan)); cmmts.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TODMTFTIMEINTERVAL"))); /* string dmtftimespan = timespan.Days.ToString().PadLeft(8,'0'); */ CodePropertyReferenceExpression cpre1 = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(timespan),"Days" ); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression( new CodeCastExpression( new CodeTypeReference("System.Int32 "), cpre1 ), "ToString" ); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(cmie,"PadLeft"); cmie1.Parameters.Add(new CodePrimitiveExpression(8)); cmie1.Parameters.Add(new CodePrimitiveExpression('0')); cmmts.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.String"), dmtfTimeSpan, cmie1 ) ); CodeObjectCreateExpression codeThrowException = new CodeObjectCreateExpression(); codeThrowException.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); /* System.Timespan maxTimeSpan = System.TimeSpan.MaxValue ; if (timespan.Days > maxTimeSpan.Days) { throw new System.ArgumentOutOfRangeException(); } */ CodeFieldReferenceExpression cpreMaxVal = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"MaxValue"); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),"maxTimeSpan",cpreMaxVal)); CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(timespan), "Days" ); cboe.Operator = CodeBinaryOperatorType.GreaterThan; cboe.Right = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression("maxTimeSpan"), "Days" ); CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* System.TimeSpan minTimeSpan = System.TimeSpan.MinValue ; if (timespan.Days < minTimeSpan.Days) { throw new System.ArgumentOutOfRangeException(); } */ CodeFieldReferenceExpression cpreMinVal = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"MinValue"); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),"minTimeSpan",cpreMinVal)); CodeBinaryOperatorExpression cboe3 = new CodeBinaryOperatorExpression(); cboe3.Left = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(timespan), "Days" ); cboe3.Operator = CodeBinaryOperatorType.LessThan; cboe3.Right = new CodePropertyReferenceExpression( new CodeVariableReferenceExpression("minTimeSpan"), "Days" ); CodeConditionStatement cis2 = new CodeConditionStatement(); cis2.Condition = cboe3; cis2.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis2); /* dmtftimespan = (dmtftimespan + timespan.Hours.ToString().PadLeft(2, '0')); */ cpre1 = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Hours"); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int32 "),cpre1),"ToString"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(cmie,"PadLeft"); cmie1.Parameters.Add(new CodePrimitiveExpression(2)); cmie1.Parameters.Add(new CodePrimitiveExpression('0')); CodeMethodInvokeExpression cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie1); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); /* dmtftimespan = (dmtftimespan + timespan.Minutes.ToString().PadLeft(2, '0')); */ cpre1 = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Minutes"); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int32 "),cpre1),"ToString"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(cmie,"PadLeft"); cmie1.Parameters.Add(new CodePrimitiveExpression(2)); cmie1.Parameters.Add(new CodePrimitiveExpression('0')); cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie1); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); /* dmtftimespan = (dmtftimespan + timespan.Seconds.ToString().PadLeft(2, '0')); */ cpre1 = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Seconds"); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int32 "),cpre1),"ToString"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(cmie,"PadLeft"); cmie1.Parameters.Add(new CodePrimitiveExpression(2)); cmie1.Parameters.Add(new CodePrimitiveExpression('0')); cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie1); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); /* dmtftimespan = dmtftimespan + "."; */ cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),new CodePrimitiveExpression(".")); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); /* TimeSpan tsTemp = new TimeSpan(timespan.Days ,timespan.Hours,timespan.Minutes ,timespan.Seconds ,0); */ coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Days")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Hours")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Minutes")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Seconds")); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),tsTemp,coce)); /* System.Int64 microsec = ((timespan.Ticks-tsTemp.Ticks) * 1000) / System.TimeSpan.TicksPerMillisecond; */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(timespan),"Ticks"); cboe.Right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tsTemp),"Ticks"); cboe.Operator = CodeBinaryOperatorType.Subtract; CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = cboe; cboe1.Right = new CodePrimitiveExpression(1000); cboe1.Operator = CodeBinaryOperatorType.Multiply; CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cboe1; cboe2.Right = new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("System.TimeSpan"), "TicksPerMillisecond" ); cboe2.Operator = CodeBinaryOperatorType.Divide; cmmts.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int64"), microsec, new CodeCastExpression("System.Int64", cboe2) ) ); /* System.String strMicrosec = microsec.ToString(); */ cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int64 "),new CodeVariableReferenceExpression(microsec)),"ToString"); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),strmicrosec,cmie)); /* if(strMicrosec.Length > 6) { strMicrosec = strMicrosec.Substring(0,6); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"Length"); cboe.Right = new CodePrimitiveExpression(6); cboe.Operator = CodeBinaryOperatorType.GreaterThan; cis = new CodeConditionStatement(); cis.Condition = cboe; cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(0)); cmie.Parameters.Add(new CodePrimitiveExpression(6)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strmicrosec),cmie)); cmmts.Statements.Add(cis); /* dmtftimespan = dmtftimespan + strMicrosec.PadLeft(6,'0'); */ cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"PadLeft"); cmie.Parameters.Add(new CodePrimitiveExpression(6)); cmie.Parameters.Add(new CodePrimitiveExpression('0')); cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfTimeSpan),new CodePrimitiveExpression(":000")); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfTimeSpan),cmie2)); cmmts.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(dmtfTimeSpan))); cc.Members.Add(cmmts); } void AddToDMTFDateTimeFunction() { String strUtc = "utcString"; String dateParam = "date"; CodeCastExpression cast = null; CodeMemberMethod cmmdt = new CodeMemberMethod(); cmmdt.Name = PrivateNamesUsed["ToDMTFDateTimeMethod"].ToString(); cmmdt.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmdt.ReturnType = new CodeTypeReference("System.String"); cmmdt.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.DateTime"),dateParam)); cmmdt.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TODMTFDATETIME"))); /* string UtcString = String.Empty; */ cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),strUtc, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.String"),"Empty"))); /* System.TimeSpan tickOffset = System.TimeZone.CurrentTimeZone.GetUtcOffset(date); long OffsetMins = tickOffset.Ticks / System.TimeSpan.TicksPerMinute; */ CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression( new CodePropertyReferenceExpression( new CodeTypeReferenceExpression("System.TimeZone"), "CurrentTimeZone" ), "GetUtcOffset" ); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre; cmie1.Parameters.Add(new CodeVariableReferenceExpression(dateParam)); String tickoffset = "tickOffset"; cmmdt.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.TimeSpan"), tickoffset, cmie1 ) ); String OffsetMins = "OffsetMins"; cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tickoffset),"Ticks"); cboe.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMinute"); cboe.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe); cmmdt.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int64"), OffsetMins, cast ) ); /* if(Math.Abs(OffsetMins) > MAXSIZE_UTC_DMTF) { date = date.ToUniversalTime(); UtcString = "+000"; } */ cmre = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Math"),"Abs"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre; cmie1.Parameters.Add(new CodeVariableReferenceExpression(OffsetMins)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie1; cboe.Right = new CodePrimitiveExpression(999); cboe.Operator = CodeBinaryOperatorType.GreaterThan; CodeConditionStatement cis1 = new CodeConditionStatement(); cis1.Condition = cboe; cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dateParam),"ToUniversalTime"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre; cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dateParam),cmie1)); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strUtc),new CodePrimitiveExpression("+000"))); /* else if ((tickOffset.Ticks >= 0)) { UtcString = "+" + ((tickOffset.Ticks / System.TimeSpan.TicksPerMinute)).ToString().PadLeft(3,'0'); } */ CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tickoffset),"Ticks"); cboe1.Right = new CodePrimitiveExpression(0); cboe1.Operator = CodeBinaryOperatorType.GreaterThanOrEqual; CodeConditionStatement cis2 = new CodeConditionStatement(); cis2.Condition = cboe1; CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tickoffset),"Ticks"); cboe2.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMinute"); cboe2.Operator = CodeBinaryOperatorType.Divide; cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int64 "),cboe2),"ToString"); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = new CodeMethodReferenceExpression(cmie1,"PadLeft"); cmie2.Parameters.Add(new CodePrimitiveExpression(3)); cmie2.Parameters.Add(new CodePrimitiveExpression('0')); cis2.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strUtc), GenerateConcatStrings(new CodePrimitiveExpression("+"),cmie2))); /* else { string strTemp = OffsetMins.ToString(); UtcString = "-" + strTemp.Substring(1, strTemp.Length-1).PadLeft(3,'0'); } */ cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int64 "),new CodeVariableReferenceExpression(OffsetMins)),"ToString"); cis2.FalseStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),"strTemp",cmie1)); cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression("strTemp"),"Substring"); cmie2.Parameters.Add(new CodePrimitiveExpression(1)); cmie2.Parameters.Add(new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("strTemp"),"Length"), CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1))); CodeMethodInvokeExpression cmie3 = new CodeMethodInvokeExpression(); cmie3.Method = new CodeMethodReferenceExpression(cmie2,"PadLeft"); cmie3.Parameters.Add(new CodePrimitiveExpression(3)); cmie3.Parameters.Add(new CodePrimitiveExpression('0')); cis2.FalseStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strUtc), GenerateConcatStrings(new CodePrimitiveExpression("-"),cmie3))); cis1.FalseStatements.Add(cis2); cmmdt.Statements.Add(cis1); /* string dmtfDateTime = date.Year.ToString().PadLeft(4,'0'); */ String dmtfDateTime = "dmtfDateTime"; cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int32 "), new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam), "Year")),"ToString"); cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = new CodeMethodReferenceExpression(cmie1,"PadLeft"); cmie2.Parameters.Add(new CodePrimitiveExpression(4)); cmie2.Parameters.Add(new CodePrimitiveExpression('0')); cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),dmtfDateTime,cmie2)); /* dmtfDateTime = (dmtfDateTime + date.Month.ToString().PadLeft(2, '0')); */ ToDMTFDateHelper("Month",cmmdt,"System.Int32 "); /* dmtfDateTime = (dmtfDateTime + date.Day.ToString().PadLeft(2, '0')); */ ToDMTFDateHelper("Day",cmmdt,"System.Int32 "); /* dmtfDateTime = (dmtfDateTime + date.Hour.ToString().PadLeft(2, '0')); */ ToDMTFDateHelper("Hour",cmmdt,"System.Int32 "); /* dmtfDateTime = (dmtfDateTime + date.Minute.ToString().PadLeft(2, '0')); */ ToDMTFDateHelper("Minute",cmmdt,"System.Int32 "); /* dmtfDateTime = (dmtfDateTime + date.Second.ToString().PadLeft(2, '0')); */ ToDMTFDateHelper("Second",cmmdt,"System.Int32 "); /* dmtfDateTime = (dmtfDateTime + "."); */ cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfDateTime), GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfDateTime),new CodePrimitiveExpression(".")))); /* DateTime dtTemp = new DateTime(date.Year ,date.Month,date.Day ,date.Hour ,date.Minute ,date.Second,0); */ String dtTemp = "dtTemp"; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.DateTime"); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Year")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Month")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Day")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Hour")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Minute")); coce.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Second")); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.DateTime"),dtTemp,coce)); /* System.Int64 microsec = ((date.Ticks-dtTemp.Ticks) * 1000) / System.TimeSpan.TicksPerMillisecond; */ String microsec = "microsec"; cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam),"Ticks"); cboe.Right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dtTemp),"Ticks"); cboe.Operator = CodeBinaryOperatorType.Subtract; cboe1 = new CodeBinaryOperatorExpression(); cboe1.Left = cboe; cboe1.Right = new CodePrimitiveExpression(1000); cboe1.Operator = CodeBinaryOperatorType.Multiply; cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cboe1; cboe2.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMillisecond"); cboe2.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe2); cmmdt.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int64"), microsec, cast ) ); /* System.String strMicrosec = microsec.ToString(); */ String strmicrosec = "strMicrosec"; cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference("System.Int64 "), new CodeVariableReferenceExpression(microsec)),"ToString"); cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),strmicrosec,cmie1)); /* if(strMicrosec.Length > 6) { strMicrosec = strMicrosec.Substring(0,6); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"Length"); cboe.Right = new CodePrimitiveExpression(6); cboe.Operator = CodeBinaryOperatorType.GreaterThan; cis1 = new CodeConditionStatement(); cis1.Condition = cboe; cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"Substring"); cmie1.Parameters.Add(new CodePrimitiveExpression(0)); cmie1.Parameters.Add(new CodePrimitiveExpression(6)); cis1.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strmicrosec),cmie1)); cmmdt.Statements.Add(cis1); /* dmtfDateTime = dmtfDateTime + strMicrosec.PadLeft(6,'0'); */ cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(strmicrosec),"PadLeft"); cmie1.Parameters.Add(new CodePrimitiveExpression(6)); cmie1.Parameters.Add(new CodePrimitiveExpression('0')); cmie2 = GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfDateTime),cmie1); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfDateTime),cmie2)); /* dmtfDateTime = dmtfDateTime + UtcString; */ cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfDateTime), GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfDateTime), new CodeVariableReferenceExpression(strUtc)))); cmmdt.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(dmtfDateTime))); cc.Members.Add(cmmdt); } // Helper function exclusively added to be used from AddToDMTFFunction function void ToDMTFDateHelper(string dateTimeMember,CodeMemberMethod cmmdt,string strType) { String dmtfDateTime = "dmtfDateTime"; String dateParam = "date"; CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeCastExpression(new CodeTypeReference(strType), new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dateParam), dateTimeMember)),"ToString"); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = new CodeMethodReferenceExpression(cmie,"PadLeft"); cmie2.Parameters.Add(new CodePrimitiveExpression(2)); cmie2.Parameters.Add(new CodePrimitiveExpression('0')); CodeMethodInvokeExpression cmie3 = GenerateConcatStrings(cmie,cmie2); /* new CodeMethodInvokeExpression(); cmie3.Method = new CodeMethodReferenceExpression(cmie,"Concat"); cmie3.Parameters.Add(cmie2); */ cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(dmtfDateTime), GenerateConcatStrings(new CodeVariableReferenceExpression(dmtfDateTime), cmie2))); } void AddToTimeSpanFunction() { String tsParam = "dmtfTimespan"; String days = "days"; String hours = "hours"; String minutes = "minutes"; String seconds = "seconds"; String ticks = "ticks"; CodeMemberMethod cmmts = new CodeMemberMethod(); cmmts.Name = PrivateNamesUsed["ToTimeSpanMethod"].ToString(); cmmts.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmts.ReturnType = new CodeTypeReference("System.TimeSpan"); cmmts.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.String"),tsParam)); cmmts.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TOTIMESPAN"))); //Int32 days = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),days,new CodePrimitiveExpression(0))); //Int32 hours = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),hours,new CodePrimitiveExpression(0))); //Int32 minutes = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),minutes,new CodePrimitiveExpression(0))); //Int32 seconds = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),seconds,new CodePrimitiveExpression(0))); //Int32 ticks = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int64"),ticks,new CodePrimitiveExpression(0))); /* if (dmtfTimespan == null) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(tsParam); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; CodeObjectCreateExpression codeThrowException = new CodeObjectCreateExpression(); codeThrowException.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if (dmtfTimespan.Length == 0) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Length"); cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if (dmtfTimespan.Length != DMTF_DATETIME_STR_LENGTH ) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Length"); cboe.Right = new CodePrimitiveExpression(DMTF_DATETIME_STR_LENGTH); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if(dmtfTimespan.Substring(21,4) != ":000") { throw new System.ArgumentOutOfRangeException(); } */ CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(21)); cmie.Parameters.Add(new CodePrimitiveExpression(4)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(":000"); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); CodeTryCatchFinallyStatement tryblock = new CodeTryCatchFinallyStatement(); /* string tempString = System.String.Empty; */ string strTemp = "tempString"; tryblock.TryStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),strTemp, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.String"),"Empty"))); /* tempString = dmtfTimespan.Substring(0, 8); days = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(8, 2); hours = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(10, 2); minutes = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(12, 2); seconds = System.Int32.Parse(tempString); */ ToTimeSpanHelper(0,8,days,tryblock.TryStatements); ToTimeSpanHelper(8,2,hours,tryblock.TryStatements); ToTimeSpanHelper(10,2,minutes,tryblock.TryStatements); ToTimeSpanHelper(12,2,seconds,tryblock.TryStatements); /* tempString = dmtfTimespan.Substring(15, 6); */ cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(15)); cmie.Parameters.Add(new CodePrimitiveExpression(6)); tryblock.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strTemp),cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int64"),"Parse"); cmie.Parameters.Add(new CodeVariableReferenceExpression(strTemp)); /* ticks = (System.Int64.Parse(tempString)) * (System.TimeSpan.TicksPerMillisecond/1000); */ tryblock.TryStatements.Add ( new CodeAssignStatement( new CodeVariableReferenceExpression(ticks), new CodeBinaryOperatorExpression( cmie, CodeBinaryOperatorType.Multiply, new CodeCastExpression( "System.Int64", new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("System.TimeSpan"), "TicksPerMillisecond" ), CodeBinaryOperatorType.Divide, new CodePrimitiveExpression(1000) ) ) ) ) ); /* if( days < 0 || hours < 0 || minutes < 0 || seconds < 0 || ticks < 0) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboeDays = new CodeBinaryOperatorExpression(); cboeDays.Left = new CodeVariableReferenceExpression(days); cboeDays.Right = new CodePrimitiveExpression(0); cboeDays.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeHours = new CodeBinaryOperatorExpression(); cboeHours.Left = new CodeVariableReferenceExpression(hours); cboeHours.Right = new CodePrimitiveExpression(0); cboeHours.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMinutes = new CodeBinaryOperatorExpression(); cboeMinutes.Left = new CodeVariableReferenceExpression(minutes); cboeMinutes.Right = new CodePrimitiveExpression(0); cboeMinutes.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeSeconds = new CodeBinaryOperatorExpression(); cboeSeconds.Left = new CodeVariableReferenceExpression(seconds); cboeSeconds.Right = new CodePrimitiveExpression(0); cboeSeconds.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeTicks = new CodeBinaryOperatorExpression(); cboeTicks.Left = new CodeVariableReferenceExpression(ticks); cboeTicks.Right = new CodePrimitiveExpression(0); cboeTicks.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboetemp1 = new CodeBinaryOperatorExpression(); cboetemp1.Left = cboeDays; cboetemp1.Right = cboeHours; cboetemp1.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp2 = new CodeBinaryOperatorExpression(); cboetemp2.Left = cboetemp1; cboetemp2.Right = cboeMinutes; cboetemp2.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp3 = new CodeBinaryOperatorExpression(); cboetemp3.Left = cboetemp2; cboetemp3.Right = cboeSeconds; cboetemp3.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp4 = new CodeBinaryOperatorExpression(); cboetemp4.Left = cboetemp3; cboetemp4.Right = cboeTicks; cboetemp4.Operator = CodeBinaryOperatorType.BooleanOr; cis = new CodeConditionStatement(); cis.Condition = cboetemp4; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); /* catch { throw new System.ArgumentOutOfRangeException(null, e.Message); } */ string exceptVar = "e"; CodeCatchClause catchblock = new CodeCatchClause(exceptVar); CodeObjectCreateExpression codeThrowExceptionWithArgs = new CodeObjectCreateExpression(); codeThrowExceptionWithArgs.CreateType = new CodeTypeReference (PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); codeThrowExceptionWithArgs.Parameters.Add(new CodePrimitiveExpression(null)); codeThrowExceptionWithArgs.Parameters.Add ( new CodePropertyReferenceExpression ( new CodeVariableReferenceExpression(exceptVar), "Message" ) ); catchblock.Statements.Add(new CodeThrowExceptionStatement(codeThrowExceptionWithArgs)); // // add the catch block to the try block // tryblock.CatchClauses.Add(catchblock); // // add the try block to cmmts // cmmts.Statements.Add(tryblock); /* timespan = new System.TimeSpan(days, hours, minutes, seconds, 0); */ string timespan = "timespan"; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodeVariableReferenceExpression(days)); coce.Parameters.Add(new CodeVariableReferenceExpression(hours)); coce.Parameters.Add(new CodeVariableReferenceExpression(minutes)); coce.Parameters.Add(new CodeVariableReferenceExpression(seconds)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),timespan,coce)); /* TimeSpan tsTemp = System.TimeSpan.FromTicks(ticks); timespan = timespan.Add(tsTemp); */ string tsTemp = "tsTemp"; cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"FromTicks"); cmie.Parameters.Add(new CodeVariableReferenceExpression(ticks)); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),tsTemp,cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(timespan),"Add"); cmie.Parameters.Add(new CodeVariableReferenceExpression(tsTemp)); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(timespan),cmie)); /* return timespan; */ cmmts.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(timespan))); cc.Members.Add(cmmts); } // Exclusive helper function to be used from AddToTimeSpanFunction static void ToTimeSpanHelper(int start,int numOfCharacters,String strVarToAssign,CodeStatementCollection statCol) { String strTemp = "tempString"; String tsParam = "dmtfTimespan"; CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(start)); cmie.Parameters.Add(new CodePrimitiveExpression(numOfCharacters)); statCol.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strTemp),cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int32"),"Parse"); cmie.Parameters.Add(new CodeVariableReferenceExpression(strTemp)); statCol.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strVarToAssign),cmie)); } void InitPrivateMemberVariables(CodeMemberMethod cmMethod) { CodeMethodInvokeExpression cmieInit = new CodeMethodInvokeExpression(); cmieInit.Method.MethodName = PrivateNamesUsed["initVariable"].ToString(); cmMethod.Statements.Add(cmieInit); } void GenerateMethodToInitializeVariables() { CodeMemberMethod cmmInit = new CodeMemberMethod (); cmmInit.Name = PrivateNamesUsed["initVariable"].ToString(); cmmInit.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmmInit.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["AutoCommitProperty"].ToString()), new CodePrimitiveExpression(true))); cmmInit.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(PrivateNamesUsed["IsEmbedded"].ToString()), new CodePrimitiveExpression(false))); cc.Members.Add(cmmInit); } // static CodeMethodInvokeExpression GenerateConcatStrings(CodeExpression ce1,CodeExpression ce2) { CodeExpression []cmieParams = {ce1,ce2 }; CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("System.String"), "Concat", cmieParams); return cmie; } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XsltConvert.cs
- SQLChars.cs
- sqlcontext.cs
- InputEventArgs.cs
- MemberInfoSerializationHolder.cs
- IntegrationExceptionEventArgs.cs
- Source.cs
- TableFieldsEditor.cs
- HealthMonitoringSectionHelper.cs
- SourceCollection.cs
- ThicknessKeyFrameCollection.cs
- ApplicationSecurityManager.cs
- RepeaterItemEventArgs.cs
- mactripleDES.cs
- UIPropertyMetadata.cs
- RuleConditionDialog.Designer.cs
- XhtmlBasicCalendarAdapter.cs
- HwndMouseInputProvider.cs
- UnsafeNativeMethods.cs
- ComponentResourceKey.cs
- TypeGeneratedEventArgs.cs
- SslStreamSecurityUpgradeProvider.cs
- XmlNamespaceDeclarationsAttribute.cs
- ListViewHitTestInfo.cs
- Int32KeyFrameCollection.cs
- Decimal.cs
- ReadingWritingEntityEventArgs.cs
- Vector3DConverter.cs
- MessageBox.cs
- DrawingBrush.cs
- XPathScanner.cs
- TypeExtensionConverter.cs
- HatchBrush.cs
- DefaultTextStoreTextComposition.cs
- VirtualizedCellInfoCollection.cs
- CollectionViewGroupRoot.cs
- ProgressChangedEventArgs.cs
- XmlQueryStaticData.cs
- ResourceManager.cs
- SafePipeHandle.cs
- OrderByBuilder.cs
- InkCanvas.cs
- TextUtf8RawTextWriter.cs
- Point3DKeyFrameCollection.cs
- ProxyElement.cs
- ColumnWidthChangedEvent.cs
- JsonDataContract.cs
- ObjectToken.cs
- TreeWalkHelper.cs
- MultipleViewPatternIdentifiers.cs
- IPipelineRuntime.cs
- SqlInternalConnection.cs
- QuadraticBezierSegment.cs
- ReadContentAsBinaryHelper.cs
- Pen.cs
- CacheVirtualItemsEvent.cs
- DataGridViewCellValueEventArgs.cs
- DbDataRecord.cs
- Formatter.cs
- SspiSafeHandles.cs
- ClonableStack.cs
- TrustManagerPromptUI.cs
- BulletDecorator.cs
- ConnectionConsumerAttribute.cs
- MethodCallTranslator.cs
- MenuStrip.cs
- __Filters.cs
- PreProcessor.cs
- Baml6ConstructorInfo.cs
- UniformGrid.cs
- RadioButtonRenderer.cs
- DecoderFallbackWithFailureFlag.cs
- TextPatternIdentifiers.cs
- MetadataPropertyCollection.cs
- PrimitiveType.cs
- ValidatedControlConverter.cs
- MemberDescriptor.cs
- BuilderPropertyEntry.cs
- MonitoringDescriptionAttribute.cs
- IntPtr.cs
- ContextStaticAttribute.cs
- ResourceContainer.cs
- ImageList.cs
- SqlDataSourceFilteringEventArgs.cs
- ProtectedUri.cs
- RuleDefinitions.cs
- SparseMemoryStream.cs
- TaiwanCalendar.cs
- XmlDownloadManager.cs
- BufferedGraphicsManager.cs
- WindowsAuthenticationModule.cs
- Transform3DGroup.cs
- DeclaredTypeElement.cs
- FlagsAttribute.cs
- SamlAction.cs
- Condition.cs
- DecoratedNameAttribute.cs
- ProfessionalColors.cs
- StatusBarPanelClickEvent.cs
- PriorityChain.cs