C# IContext.WriteVerbose方法代码示例

        public void RemoveItem(IContext context, string path, bool recurse)
        {
            var ddl = "DROP TABLE " + path;
            context.WriteVerbose( ddl );

            var cmd = _context.CreateCommand(ddl);
            cmd.ExecuteNonQuery();
        }

        public void RemoveItem(IContext context, string path, bool recurse)
        {
            var factory = new DynamicParametersFactory(_context, _record.Table.TableName);
            var sql = factory.ToDeleteRecord( PrimaryKey );

            context.WriteVerbose("DELETE SQL: " + sql);
            _context.Execute(sql);
        }

        public IPathNode SetItem(IContext context, string path, object value)
        {
            var factory = new DynamicParametersFactory(_context, _record.Table.TableName);

            //TODO: invert sql generation and parameter snooping to update only specified fields
            var cmd = factory.ToUpdate();

            context.WriteVerbose("UPDATE SQL: " + cmd.CommandText);
            
            factory.Parameterize(cmd, PrimaryKey, value, context.DynamicParameters as RuntimeDefinedParameterDictionary);

            cmd.ExecuteNonQuery();
            return GetNodeValue();
        }

        public override IEnumerable<INodeFactory> GetNodeChildren( IContext context )
        {
            var filter = context.Filter;
            var sql = "SELECT * FROM " + Name;
            if( ! String.IsNullOrEmpty( filter ) )
            {
                sql += " WHERE ( " + filter + " )";
            }
            var command = new SqliteCommand(sql , _context.Connection);
            var table = new DataTable( Name );
            
            context.WriteVerbose( sql );
            using( var data = new SqliteDataAdapter(command) )
            {
                data.MissingSchemaAction = MissingSchemaAction.AddWithKey;
                data.Fill(table);
            }

            foreach( DataRow row in table.Rows )
            {
                yield return new SQLiteRecordNodeFactory( _context, row);
            }
        }

        public IPathNode NewItem(IContext context, string path, string itemTypeName, object newItemValue)
        {
            var parameterDictionary = context.DynamicParameters as RuntimeDefinedParameterDictionary;
            var value = newItemValue.ToPSObject();
            
            var factory = new DynamicParametersFactory(_context, Name);
            var command = factory.ToInsert();
            
            context.WriteVerbose( "INSERT SQL: " + command.CommandText );

            factory.Parameterize(command, value, parameterDictionary);

            foreach (SqliteParameter param in command.Parameters)
            {
                context.WriteVerbose("PARAMETERS: @" + param.ParameterName + " = [" + param.Value + "]");
            }

            var id = command.ExecuteScalar();
            
            return Resolve(context, id.ToString()).First().GetNodeValue();
        }

        public IEnumerable<object> InvokeItem(IContext context, string path)
        {
            InvokeItemParameters parameters =
                context.DynamicParameters as InvokeItemParameters;

            var filter = context.Filter;
            var sql = parameters.Sql;
            if (String.IsNullOrEmpty(sql))
            {
                return null;
            }

            var command = new SqliteCommand(sql, _context.Connection);
            context.WriteVerbose(sql);
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    PSObject record = new PSObject();
                    for (int c = 0; c < reader.FieldCount; ++c)
                    {
                        var name = reader.GetName(c);
                        var value = reader.GetValue(c);
                        record.Properties.Add(new PSNoteProperty(name, value));
                    }

                    context.WriteItemObject(record, path, false);
                    //yield return new SQLiteRecordNodeFactory(_sqliteContext, reader.);
                }
            }

            return null;
        }

        public IPathNode NewItem(IContext context, string path, string itemTypeName, object newItemValue)
        {
            string ddl = newItemValue as string;
            var schema = newItemValue as Hashtable;
            var parameters = context.DynamicParameters as NewTableParameters;
			path = RemoveInvalidChars (path);
            if( null != ddl)
            {
                ddl = String.Format(@"CREATE TABLE {0} ( {1} )", path, ddl);
            }
            else if (null != schema)
            {
                var coldefs = ConvertToColumnDefinitionDDL(schema);
                ddl = String.Format(@"CREATE TABLE {0} ( {1} )", path, coldefs);
            }
            else if( null != parameters)
            {
                var coldefs = ConvertToColumnDefinitionDDL(parameters);
                ddl = String.Format(@"CREATE TABLE {0} ( {1} )", path, coldefs);
            }

            if ( null == ddl )
            {
                throw new ArgumentException(
                    @"The new table schema must be specified as a DDL string, a hashtable of column names associated with SQLite DDL strings, or as individual parameters.  For instance:
new-item mydb:/tableOfNames -value @{ 
    id = 'INTEGER PRIMARY KEY';
    name = 'TEXT NOT NULL';
    ...
}

or

new-item mydb:/tableOfNames -value 'id INTEGER PRIMARY KEY, name TEXT NOT NULL'

or

new-item mydb:/tableOfNames -id INTEGER PRIMARY KEY -name TEXT NOT NULL
",
                    "newItemValue"
                );
            } 
                        
            context.WriteVerbose(ddl);

            var cmd = _sqliteContext.CreateCommand(ddl);
            cmd.ExecuteNonQuery();

            var node = Resolve(context, path);
            if( null == node || ! node.Any() )
            {
                throw new InvalidOperationException( "Failed to create new table " + path );
            }
            return node.First().GetNodeValue();
        }

        protected IPathNode NewChildItem(string thisCodeItemTypeName, IEnumerable<string> newItemTypeNames,
                                         IContext context, string path, string itemTypeName, object newItemValue)
        {
            if (!newItemTypeNames.Contains(itemTypeName, StringComparer.InvariantCultureIgnoreCase))
            {
                WriteNotSupportedItemTypeError(thisCodeItemTypeName, context, itemTypeName, path);

                return null;
            }

            object item = null;
            var p = context.DynamicParameters as NewCodeElementItemParams;

            switch (itemTypeName.ToLowerInvariant())
            {
                case CodeItemTypes.Attribute:
                    item = NewAttribute(p, path, newItemValue);
                    break;
                case CodeItemTypes.Class:
                    item = NewClass(p, path);
                    break;
                case CodeItemTypes.Delegate:
                    item = NewDelegate(p, path);
                    break;
                case CodeItemTypes.Enum:
                    item = NewEnum(p, path);
                    break;
                case CodeItemTypes.Event:
                    item = NewEvent(p, path);
                    break;
                case CodeItemTypes.Method:
                    p.MemberType = p.MemberType ?? "void";
                    item = NewMethod(p, path);
                    break;
                case CodeItemTypes.Property:
                    if (!(p.Set || p.Get))
                    {
                        context.WriteVerbose( "using new-item to create a new property element, but neither -get nor -set are supplied; assuming you want both -get and -set");
                        p.Get = p.Set = true;
                    }
                    item = NewProperty(p, path);
                    break;
                case CodeItemTypes.Struct:
                    item = NewStruct(p, path);
                    break;
                case CodeItemTypes.Variable:
                    item = NewVariable(p, path, newItemValue);
                    break;
                case CodeItemTypes.Parameter:
                    item = NewParameter(p, path, newItemValue);
                    break;
                case CodeItemTypes.Namespace:
                    item = NewNamespace(p, path);
                    break;
                case CodeItemTypes.Interface:
                    item = NewInterface(p, path);
                    break;

                default:
                    item = null;
                    break;
            }

            if (null == item)
            {
                WriteNotSupportedItemTypeError(thisCodeItemTypeName, context, itemTypeName, path);

                return null;
            }

            var shellItem = ShellObjectFactory.CreateFromCodeElement(item as CodeElement);
            return new PathNode(shellItem, shellItem.Name, shellItem.IsContainer);
        }