C# MutableString.ToString方法代码示例

            public static RubyArray Execute(RhoDatabase/*!*/ self, MutableString/*!*/ sqlStatement, Boolean isBatch, RubyArray args)
            {
                try
                {
                    RubyArray retArr = new RubyArray();

                    if (isBatch)
                    {
                        self.m_db.executeBatchSQL(sqlStatement.ToString());
                    }
                    else
                    {
                        Object[] values = null;
                        if (args != null && args.Count > 0)
                        {
                            if (args[0] != null && args[0] is RubyArray)
                                values = ((RubyArray)args[0]).ToArray();
                            else
                                values = args.ToArray();
                        }

                        try
                        {
                            self.m_db.Lock();
                            using (IDBResult rows = self.m_db.executeSQL(sqlStatement.ToString(), values, true))
                            {
                                if (rows != null)
                                {
                                    MutableString[] colNames = null;
                                    for (; !rows.isEnd(); rows.next())
                                    {
                                        IDictionary<object, object> map = new Dictionary<object, object>();
                                        Hash row = new Hash(map);
                                        for (int nCol = 0; nCol < rows.getColCount(); nCol++)
                                        {
                                            if (colNames == null)
                                                colNames = getOrigColNames(rows);

                                            row.Add(colNames[nCol], rows.getRubyValueByIdx(nCol));
                                        }
                                        retArr.Add(row);
                                    }
                                }
                            }
                        }
                        finally
                        {
                            self.m_db.Unlock();
                        }
                    }

                    return retArr;
                }catch (Exception exc)
                {
                    //TODO: throw ruby exception
                    throw exc;
                }
            }

        public static IOInfo Parse(RubyContext/*!*/ context, MutableString/*!*/ modeAndEncoding) {
            if (!modeAndEncoding.IsAscii()) {
                throw IOModeEnum.IllegalMode(modeAndEncoding.ToAsciiString(false));
            }

            string[] parts = modeAndEncoding.ToString().Split(':');
            return new IOInfo(
                IOModeEnum.Parse(parts[0]),
                (parts.Length > 1) ? TryParseEncoding(context, parts[1]) : null,
                (parts.Length > 2) ? TryParseEncoding(context, parts[2]) : null
            );
        }

 internal static Process/*!*/ CreateProcess(RubyContext/*!*/ context, MutableString/*!*/ command, MutableString[]/*!*/ args) {
     var psi = new ProcessStartInfo(command.ToString(), JoinArguments(args).ToString());
     psi.UseShellExecute = false;
     psi.RedirectStandardError = true;
     try {
         Utils.Log(String.Format("Starting: '{0}' with args: '{1}'", psi.FileName, psi.Arguments), "PROCESS");
         Process p = Process.Start(psi);
         p.WaitForExit();
         context.ChildProcessExitStatus = new RubyProcess.Status(p);
         return p;
     } catch (Exception e) {
         throw RubyExceptions.CreateENOENT(psi.FileName, e);
     }
 }

 public static Boolean isTableExist(RhoDatabase/*!*/ self, MutableString/*!*/ tblName)
 {
     return self.m_db.isTableExist( tblName.ToString() );
 }

 // Executes a command directly in a child process - command is the name of the executable
 private static Process/*!*/ ExecuteCommand(MutableString/*!*/ command, MutableString[]/*!*/ args) {
     return ExecuteProcessAndWait(new ProcessStartInfo(command.ToString(), JoinArguments(args).ToString()));
 }

        private static MutableString/*!*/ BaseName(MutableString/*!*/ path, MutableString suffix) {
            if (path.IsEmpty) {
                return path;
            }

            string strPath = path.ConvertToString();
            string[] parts = strPath.Split(new[] { DirectorySeparatorChar, AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);

            if (parts.Length == 0) {
                return MutableString.CreateMutable(path.Encoding).Append((char)path.GetLastChar()).TaintBy(path);
            }

            if (Environment.OSVersion.Platform != PlatformID.Unix && Environment.OSVersion.Platform != PlatformID.MacOSX) {
                string first = parts[0];
                if (strPath.Length >= 2 && IsDirectorySeparator(strPath[0]) && IsDirectorySeparator(strPath[1])) {
                    // UNC: skip 2 parts 
                    if (parts.Length <= 2) {
                        return MutableString.CreateMutable(path.Encoding).Append(DirectorySeparatorChar).TaintBy(path);
                    }
                } else if (first.Length == 2 && Tokenizer.IsLetter(first[0]) && first[1] == ':') {
                    // skip drive letter "X:"
                    if (parts.Length <= 1) {
                        var result = MutableString.CreateMutable(path.Encoding).TaintBy(path);
                        if (strPath.Length > 2) {
                            result.Append(strPath[2]);
                        }
                        return result;
                    }
                }
            }

            string last = parts[parts.Length - 1];
            if (MutableString.IsNullOrEmpty(suffix)) {
                return MutableString.CreateMutable(last, path.Encoding);
            }

            StringComparison comparison = Environment.OSVersion.Platform == PlatformID.Unix ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
            int matchLength = last.Length;

            if (suffix != null) {
                string strSuffix = suffix.ToString();
                if (strSuffix.LastCharacter() == '*' && strSuffix.Length > 1) {
                    int suffixIdx = last.LastIndexOf(
                        strSuffix.Substring(0, strSuffix.Length - 1),
                        comparison
                    );
                    if (suffixIdx >= 0 && suffixIdx + strSuffix.Length <= last.Length) {
                        matchLength = suffixIdx;
                    }
                } else if (last.EndsWith(strSuffix, comparison)) {
                    matchLength = last.Length - strSuffix.Length;
                }
            }

            return MutableString.CreateMutable(path.Encoding).Append(last, 0, matchLength).TaintBy(path);
        }

        public LexicalMatch MatchWithin(string value)
        {
            if (null == value)
            {
                throw new ArgumentNullException("value");
            }

            if (0 == value.Length)
            {
                return null;
            }

            var result = Match(value);
            if (null != result)
            {
                return result;
            }

            var parts = value.Split(' ');
            if (parts.Length < 2)
            {
                return null;
            }

            var mutable = new MutableString(value);
#if NET20
            foreach (var part in PartsWithin(IEnumerableExtensionMethods.ToList(mutable.ToString().Split(' '))))
#else
            foreach (var part in PartsWithin(mutable.ToString().Split(' ').ToList()))
#endif
            {
                result = Match(part);
                if (null == result)
                {
                    continue;
                }

#if NET20
                var splits = StringExtensionMethods.Split(value, part, StringSplitOptions.None);
#else
                var splits = value.Split(part, StringSplitOptions.None);
#endif
                if (2 != splits.Length)
                {
                    continue;
                }

                result.Prefix = splits[0].Trim();
                result.Suffix = splits[1].Trim();
                return result;
            }

            return null;
        }

        public static Node ToYamlNode(MutableString/*!*/ self, [NotNull]RubyRepresenter/*!*/ rep)
        {
            if (!self.IsEmpty && ContainsBinaryData(self)) {
                return rep.BaseCreateNode(self.ToByteArray());
            }

            Debug.Assert(self.IsAscii());
            string str = self.ToString();

            ScalarQuotingStyle style = ScalarQuotingStyle.None;
            if (str.StartsWith(":", StringComparison.Ordinal)) {
                style = ScalarQuotingStyle.Double;
            } else {
                style = rep.GetYamlStyle(self);
            }

            var tag = rep.GetTagUri(self, Tags.Str, typeof(MutableString));
            IList instanceVariableNames = rep.ToYamlProperties(self);
            if (instanceVariableNames.Count == 0) {
                return rep.Scalar(tag, str, style);
            }

            var map = new Dictionary<object, object>();
            rep.AddYamlProperties(map, self, instanceVariableNames, false);
            return rep.Map(
                new Dictionary<Node, Node> {
                    { rep.Scalar(null, "str", style), rep.Scalar(null, str, style) }
                },
                tag,
                map,
                FlowStyle.Block
            );
        }

        public void opIndexer_set_int()
        {
            var obj = new MutableString("Example");
            for (var i = 0; i < obj.Length; i++)
            {
                obj[i] = ' ';
            }

            const string expected = "       ";
            var actual = obj.ToString();

            Assert.Equal(expected, actual);
        }

        public void op_GetHashCode()
        {
            var obj = new MutableString("Example");

            var expected = obj.ToString().GetHashCode();
            var actual = obj.GetHashCode();

            Assert.Equal(expected, actual);
        }

 public static RubyIO/*!*/ Open(RubyContext/*!*/ context, object self, [NotNull]MutableString/*!*/ path, MutableString mode) {
     string fileName = path.ConvertToString();
     if (fileName.Length > 0 && fileName[0] == '|') {
         throw new NotImplementedError();
     }
     return new RubyFile(context, fileName, (mode != null) ? mode.ToString() : "r");
 }

        private void ParseFromBacktrace(MutableString message, RubyArray backtrace)
        {
            m_message = message.ToString();

              var trace = backtrace.Cast<MutableString>().Select((line) => line.ToString().Trim());
              var rubyPathLine =
            from line in trace
            let match = Regex.Match(line, @"(.*\.rb):(\d+)(:in\s+(.*))?$")
            let groupCnt = match.Groups.Count
            where match.Success
            let innerLoc = match.Groups[4].Value
            select new
            {
              FilePath = match.Groups[1].Value,
              FileLine = int.Parse(match.Groups[2].Value),
              InnerLoc = String.IsNullOrEmpty(innerLoc) ? "<top>" : innerLoc
            };

              var infoObj = rubyPathLine.FirstOrDefault();
              if (infoObj != null)
              {
            m_hasInfo = true;
            m_format = ErrorMessageFormat.Error;
            m_message = String.Format("{0} (in {1})", m_message, infoObj.InnerLoc);
            m_path = infoObj.FilePath;
            m_line = infoObj.FileLine;
              }
        }

 public static string ConvertString(MutableString rubyString)
 {
     return rubyString.ToString(Encoding.UTF8);
 }

        public IOInfo AddEncoding(RubyContext/*!*/ context, MutableString/*!*/ encoding) {
            if (!encoding.IsAscii()) {
                context.ReportWarning(String.Format("Unsupported encoding {0} ignored", encoding.ToAsciiString(false)));
                return this;
            }

            if (HasEncoding) {
                throw RubyExceptions.CreateArgumentError("encoding specified twice");
            }

            string[] parts = encoding.ToString().Split(':');
            return new IOInfo(
                _mode,
                TryParseEncoding(context, parts[0]),
                (parts.Length > 1) ? TryParseEncoding(context, parts[1]) : null
            );
        }

            public static Boolean isTableExist(RhoDatabase/*!*/ self, MutableString/*!*/ tblName)
            {
                Boolean res = false;
                try
                {
                    res = self.m_db.isTableExist(tblName.ToString());
                }
                catch (Exception ex)
                {
                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "table_exist?");
                }

                return res;
            }