Revert "Replaced double underscores in C# mapping by ice-prefix names"

This reverts commit c693f916141772b82da44d0ef90f64602a69d3ec.

31 files changed, 854 insertions, 854 deletions

diff --git a/cpp/src/slice2cs/CsUtil.cpp b/cpp/src/slice2cs/CsUtil.cpp
index 0f112677b7f..3487cde3fce 100644
--- a/cpp/src/slice2cs/CsUtil.cpp
+++ b/cpp/src/slice2cs/CsUtil.cpp
@@ -145,7 +145,7 @@ Slice::CsGenerator::fixId(const ContainedPtr& cont, int baseTypes, bool mangleCa
     if(contained && contained->hasMetaData("clr:property") &&
        (contained->containedType() == Contained::ContainedTypeClass || contained->containedType() == Contained::ContainedTypeStruct))
     {
-        return "_" + cont->name();
+        return cont->name() + "__prop";
     }
     else
     {
@@ -509,7 +509,7 @@ Slice::CsGenerator::writeMarshalUnmarshalCode(Output &out,
                                               const string& param,
                                               bool marshal)
 {
-    string stream = marshal ? "iceOs" : "iceIs";
+    string stream = marshal ? "os__" : "is__";
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if(builtin)
@@ -687,7 +687,7 @@ Slice::CsGenerator::writeMarshalUnmarshalCode(Output &out,
             }
             else
             {
-                out << nl << param << ".iceWrite(" << stream << ");";
+                out << nl << param << ".write__(" << stream << ");";
             }
         }
         else
@@ -698,7 +698,7 @@ Slice::CsGenerator::writeMarshalUnmarshalCode(Output &out,
             }
             else
             {
-                out << nl << param << ".iceRead(" << stream << ");";
+                out << nl << param << ".read__(" << stream << ");";
             }
         }
         return;
@@ -754,7 +754,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
                                                       int tag,
                                                       bool marshal)
 {
-    string stream = marshal ? "iceOs" : "iceIs";
+    string stream = marshal ? "os__" : "is__";
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if(builtin)
@@ -901,9 +901,9 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             out << nl << "if(" << param << ".HasValue && " << stream << ".writeOptional(" << tag
                 << ", Ice.OptionalFormat.FSize))";
             out << sb;
-            out << nl << "int icePos = " << stream << ".startSize();";
+            out << nl << "int pos__ = " << stream << ".startSize();";
             writeMarshalUnmarshalCode(out, type, param + ".Value", marshal);
-            out << nl << stream << ".endSize(icePos);";
+            out << nl << stream << ".endSize(pos__);";
             out << eb;
         }
         else
@@ -911,7 +911,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             out << nl << "if(" << stream << ".readOptional(" << tag << ", Ice.OptionalFormat.FSize))";
             out << sb;
             out << nl << stream << ".skip(4);";
-            string tmp = "iceTmpVal";
+            string tmp = "tmpVal__";
             string typeS = typeToString(type);
             out << nl << typeS << ' ' << tmp << ';';
             writeMarshalUnmarshalCode(out, type, tmp, marshal);
@@ -949,7 +949,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             out << sb;
             if(st->isVariableLength())
             {
-                out << nl << "int icePos = " << stream << ".startSize();";
+                out << nl << "int pos__ = " << stream << ".startSize();";
             }
             else
             {
@@ -958,7 +958,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             writeMarshalUnmarshalCode(out, type, param + ".Value", marshal);
             if(st->isVariableLength())
             {
-                out << nl << stream << ".endSize(icePos);";
+                out << nl << stream << ".endSize(pos__);";
             }
             out << eb;
         }
@@ -975,7 +975,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
                 out << nl << stream << ".skipSize();";
             }
             string typeS = typeToString(type);
-            string tmp = "iceTmpVal";
+            string tmp = "tmpVal__";
             if(isValueType(st))
             {
                 out << nl << typeS << ' ' << tmp << " = new " << typeS << "();";
@@ -1011,7 +1011,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             out << nl << "if(" << stream << ".readOptional(" << tag << ", Ice.OptionalFormat.Size))";
             out << sb;
             string typeS = typeToString(type);
-            string tmp = "iceTmpVal";
+            string tmp = "tmpVal__";
             out << nl << typeS << ' ' << tmp << ';';
             writeMarshalUnmarshalCode(out, type, tmp, marshal);
             out << nl << param << " = new Ice.Optional<" << typeS << ">(" << tmp << ");";
@@ -1042,7 +1042,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
         out << sb;
         if(keyType->isVariableLength() || valueType->isVariableLength())
         {
-            out << nl << "int icePos = " << stream << ".startSize();";
+            out << nl << "int pos__ = " << stream << ".startSize();";
         }
         else
         {
@@ -1053,7 +1053,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
         writeMarshalUnmarshalCode(out, type, param + ".Value", marshal);
         if(keyType->isVariableLength() || valueType->isVariableLength())
         {
-            out << nl << stream << ".endSize(icePos);";
+            out << nl << stream << ".endSize(pos__);";
         }
         out << eb;
     }
@@ -1070,7 +1070,7 @@ Slice::CsGenerator::writeOptionalMarshalUnmarshalCode(Output &out,
             out << nl << stream << ".skipSize();";
         }
         string typeS = typeToString(type);
-        string tmp = "iceTmpVal";
+        string tmp = "tmpVal__";
         out << nl << typeS << ' ' << tmp << " = new " << typeS << "();";
         writeMarshalUnmarshalCode(out, type, tmp, marshal);
         out << nl << param << " = new Ice.Optional<" << typeS << ">(" << tmp << ");";
@@ -1089,7 +1089,7 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                                                       bool marshal,
                                                       bool useHelper)
 {
-    string stream = marshal ? "iceOs" : "iceIs";
+    string stream = marshal ? "os__" : "is__";
 
     if(useHelper)
     {
@@ -1175,30 +1175,30 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                             // cannot contain Ice.Object.
                             //
                             out << nl << "Ice.ObjectPrx[] " << param << "_tmp = " << param << ".ToArray();";
-                            out << nl << "for(int iceIx = 0; iceIx < " << param << "_tmp.Length; ++iceIx)";
+                            out << nl << "for(int ix__ = 0; ix__ < " << param << "_tmp.Length; ++ix__)";
                             out << sb;
-                            out << nl << stream << ".writeProxy(" << param << "_tmp[iceIx]);";
+                            out << nl << stream << ".writeProxy(" << param << "_tmp[ix__]);";
                             out << eb;
                         }
                         else
                         {
                             out << nl << "_System.Collections.Generic.IEnumerator<" << typeS
-                                << "> iceE = " << param << ".GetEnumerator();";
-                            out << nl << "while(iceE.MoveNext())";
+                                << "> e__ = " << param << ".GetEnumerator();";
+                            out << nl << "while(e__.MoveNext())";
                             out << sb;
                             string func = (builtin->kind() == Builtin::KindObject ||
                                            builtin->kind() == Builtin::KindValue) ? "writeValue" : "writeProxy";
-                            out << nl << stream << '.' << func << "(iceE.Current);";
+                            out << nl << stream << '.' << func << "(e__.Current);";
                             out << eb;
                         }
                     }
                     else
                     {
-                        out << nl << "for(int iceIx = 0; iceIx < " << param << '.' << limitID << "; ++iceIx)";
+                        out << nl << "for(int ix__ = 0; ix__ < " << param << '.' << limitID << "; ++ix__)";
                         out << sb;
                         string func = (builtin->kind() == Builtin::KindObject ||
                                        builtin->kind() == Builtin::KindValue) ? "writeValue" : "writeProxy";
-                        out << nl << stream << '.' << func << '(' << param << "[iceIx]);";
+                        out << nl << stream << '.' << func << '(' << param << "[ix__]);";
                         out << eb;
                     }
                     out << eb;
@@ -1231,7 +1231,7 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                         {
                             out << typeToString(seq) << "(" << param << "_lenx);";
                         }
-                        out << nl << "for(int iceIx = 0; iceIx < " << param << "_lenx; ++iceIx)";
+                        out << nl << "for(int ix__ = 0; ix__ < " << param << "_lenx; ++ix__)";
                         out << sb;
                         string patcherName;
                         if(isCustom)
@@ -1250,9 +1250,9 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                         {
                             patcherName = "Sequence";
                         }
-                        out << nl << "IceInternal." << patcherName << "Patcher<Ice.Value> iceP = new IceInternal."
-                            << patcherName << "Patcher<Ice.Value>(\"::Ice::Object\", " << param << ", iceIx);";
-                        out << nl << stream << ".readValue(iceP.patch);";
+                        out << nl << "IceInternal." << patcherName << "Patcher<Ice.Value> p__ = new IceInternal."
+                            << patcherName << "Patcher<Ice.Value>(\"::Ice::Object\", " << param << ", ix__);";
+                        out << nl << stream << ".readValue(p__.patch);";
                     }
                     else
                     {
@@ -1273,17 +1273,17 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                         {
                             out << typeToString(seq) << "(" << param << "_lenx);";
                         }
-                        out << nl << "for(int iceIx = 0; iceIx < " << param << "_lenx; ++iceIx)";
+                        out << nl << "for(int ix__ = 0; ix__ < " << param << "_lenx; ++ix__)";
                         out << sb;
                         if(isArray)
                         {
-                            out << nl << param << "[iceIx] = " << stream << ".readProxy();";
+                            out << nl << param << "[ix__] = " << stream << ".readProxy();";
                         }
                         else
                         {
-                            out << nl << "Ice.ObjectPrx iceVal = new Ice.ObjectPrxHelperBase();";
-                            out << nl << "iceVal = " << stream << ".readProxy();";
-                            out << nl << param << "." << addMethod << "(iceVal);";
+                            out << nl << "Ice.ObjectPrx val__ = new Ice.ObjectPrxHelperBase();";
+                            out << nl << "val__ = " << stream << ".readProxy();";
+                            out << nl << param << "." << addMethod << "(val__);";
                         }
                     }
                     out << eb;
@@ -1338,8 +1338,8 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                         out << sb;
                         out << nl << param << " = new " << "global::" << genericType << "<"
                             << typeToString(type) << ">();";
-                        out << nl << "int iceSzx = " << stream << ".readSize();";
-                        out << nl << "for(int iceIx = 0; iceIx < iceSzx; ++iceIx)";
+                        out << nl << "int szx__ = " << stream << ".readSize();";
+                        out << nl << "for(int ix__ = 0; ix__ < szx__; ++ix__)";
                         out << sb;
                         out << nl << param << ".Add(" << stream << ".read" << func << "());";
                         out << eb;
@@ -1376,17 +1376,17 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                 // stack bottom-up here.
                 //
                 out << nl << "_System.Collections.Generic.IEnumerator<" << typeS
-                    << "> iceE = " << param << ".GetEnumerator();";
-                out << nl << "while(iceE.MoveNext())";
+                    << "> e__ = " << param << ".GetEnumerator();";
+                out << nl << "while(e__.MoveNext())";
                 out << sb;
-                out << nl << stream << ".writeValue(iceE.Current);";
+                out << nl << stream << ".writeValue(e__.Current);";
                 out << eb;
             }
             else
             {
-                out << nl << "for(int iceIx = 0; iceIx < " << param << '.' << limitID << "; ++iceIx)";
+                out << nl << "for(int ix__ = 0; ix__ < " << param << '.' << limitID << "; ++ix__)";
                 out << sb;
-                out << nl << stream << ".writeValue(" << param << "[iceIx]);";
+                out << nl << stream << ".writeValue(" << param << "[ix__]);";
                 out << eb;
             }
             out << eb;
@@ -1394,12 +1394,12 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         else
         {
             out << sb;
-            out << nl << "int iceSzx = " << stream << ".readAndCheckSeqSize("
+            out << nl << "int szx__ = " << stream << ".readAndCheckSeqSize("
                 << static_cast<unsigned>(type->minWireSize()) << ");";
             out << nl << param << " = new ";
             if(isArray)
             {
-                out << toArrayAlloc(typeS + "[]", "iceSzx");
+                out << toArrayAlloc(typeS + "[]", "szx__");
             }
             else if(isCustom)
             {
@@ -1410,16 +1410,16 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                 out << "_System.Collections.Generic." << genericType << "<" << typeS << ">(";
                 if(!isLinkedList)
                 {
-                    out << "iceSzx";
+                    out << "szx__";
                 }
                 out << ")";
             }
             else
             {
-                out << fixId(seq->scoped()) << "(iceSzx)";
+                out << fixId(seq->scoped()) << "(szx__)";
             }
             out << ';';
-            out << nl << "for(int iceIx = 0; iceIx < iceSzx; ++iceIx)";
+            out << nl << "for(int ix__ = 0; ix__ < szx__; ++ix__)";
             out << sb;
 
             string patcherName;
@@ -1441,7 +1441,7 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             }
             string scoped = ContainedPtr::dynamicCast(type)->scoped();
             out << nl << "IceInternal." << patcherName << "Patcher<" << typeS << "> spx = new IceInternal."
-                << patcherName << "Patcher<" << typeS << ">(\"" << scoped << "\", " << param << ", iceIx);";
+                << patcherName << "Patcher<" << typeS << ">(\"" << scoped << "\", " << param << ", ix__);";
             out << nl << stream << ".readValue(spx.patch);";
             out << eb;
             out << eb;
@@ -1469,18 +1469,18 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                 if(isStack)
                 {
                     out << nl << typeS << "[] " << param << "_tmp = " << param << ".ToArray();";
-                    out << nl << "for(int iceIx = 0; iceIx < " << param << "_tmp.Length; ++iceIx)";
+                    out << nl << "for(int ix__ = 0; ix__ < " << param << "_tmp.Length; ++ix__)";
                 }
                 else
                 {
                     out << nl << "_System.Collections.Generic.IEnumerator<" << typeS
-                        << "> iceE = " << param << ".GetEnumerator();";
-                    out << nl << "while(iceE.MoveNext())";
+                        << "> e__ = " << param << ".GetEnumerator();";
+                    out << nl << "while(e__.MoveNext())";
                 }
             }
             else
             {
-                out << nl << "for(int iceIx = 0; iceIx < " << param << '.' << limitID << "; ++iceIx)";
+                out << nl << "for(int ix__ = 0; ix__ < " << param << '.' << limitID << "; ++ix__)";
             }
             out << sb;
             string call;
@@ -1488,12 +1488,12 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             {
                 if(isValueType(type))
                 {
-                    call = "iceE.Current";
+                    call = "e__.Current";
                 }
                 else
                 {
-                    call = "(iceE.Current == null ? new ";
-                    call += typeS + "() : iceE.Current)";
+                    call = "(e__.Current == null ? new ";
+                    call += typeS + "() : e__.Current)";
                 }
             }
             else
@@ -1514,20 +1514,20 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                     {
                         call += "_tmp";
                     }
-                    call += "[iceIx] == null ? new " + typeS + "() : " + param;
+                    call += "[ix__] == null ? new " + typeS + "() : " + param;
                     if(isStack)
                     {
                         call += "_tmp";
                     }
                 }
-                call += "[iceIx]";
+                call += "[ix__]";
                 if(!isValueType(type))
                 {
                     call += ")";
                 }
             }
             call += ".";
-            call += "iceWrite";
+            call += "write__";
             call += "(" + stream + ");";
             out << nl << call;
             out << eb;
@@ -1536,11 +1536,11 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         else
         {
             out << sb;
-            out << nl << "int iceSzx = " << stream << ".readAndCheckSeqSize("
+            out << nl << "int szx__ = " << stream << ".readAndCheckSeqSize("
                 << static_cast<unsigned>(type->minWireSize()) << ");";
             if(isArray)
             {
-                out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+                out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
             }
             else if(isCustom)
             {
@@ -1548,44 +1548,44 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             }
             else if(isStack)
             {
-                out << nl << typeS << "[] " << param << "_tmp = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+                out << nl << typeS << "[] " << param << "__tmp = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
             }
             else if(isGeneric)
             {
                 out << nl << param << " = new _System.Collections.Generic." << genericType << "<" << typeS << ">(";
                 if(!isLinkedList)
                 {
-                    out << "iceSzx";
+                    out << "szx__";
                 }
                 out << ");";
             }
             else
             {
-                out << nl << param << " = new " << fixId(seq->scoped()) << "(iceSzx);";
+                out << nl << param << " = new " << fixId(seq->scoped()) << "(szx__);";
             }
-            out << nl << "for(int iceIx = 0; iceIx < iceSzx; ++iceIx)";
+            out << nl << "for(int ix__ = 0; ix__ < szx__; ++ix__)";
             out << sb;
             if(isArray || isStack)
             {
-                string v = isArray ? param : param + "_tmp";
+                string v = isArray ? param : param + "__tmp";
                 if(!isValueType(st))
                 {
-                    out << nl << v << "[iceIx] = new " << typeS << "();";
+                    out << nl << v << "[ix__] = new " << typeS << "();";
                 }
-                out << nl << v << "[iceIx].iceRead(" << stream << ");";
+                out << nl << v << "[ix__].read__(" << stream << ");";
             }
             else
             {
-                out << nl << typeS << " iceVal = new " << typeS << "();";
-                out << nl << "iceVal.iceRead(" << stream << ");";
-                out << nl << param << "." << addMethod << "(iceVal);";
+                out << nl << typeS << " val__ = new " << typeS << "();";
+                out << nl << "val__.read__(" << stream << ");";
+                out << nl << param << "." << addMethod << "(val__);";
             }
             out << eb;
             if(isStack)
             {
-                out << nl << "_System.Array.Reverse(" << param << "_tmp);";
+                out << nl << "_System.Array.Reverse(" << param << "__tmp);";
                 out << nl << param << " = new _System.Collections.Generic." << genericType << "<" << typeS << ">("
-                    << param << "_tmp);";
+                    << param << "__tmp);";
             }
             out << eb;
         }
@@ -1612,26 +1612,26 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
                 if(isStack)
                 {
                     out << nl << typeS << "[] " << param << "_tmp = " << param << ".ToArray();";
-                    out << nl << "for(int iceIx = 0; iceIx < " << param << "_tmp.Length; ++iceIx)";
+                    out << nl << "for(int ix__ = 0; ix__ < " << param << "_tmp.Length; ++ix__)";
                     out << sb;
-                    out << nl << stream << ".writeEnum((int)" << param << "_tmp[iceIx], " << en->maxValue() << ");";
+                    out << nl << stream << ".writeEnum((int)" << param << "_tmp[ix__], " << en->maxValue() << ");";
                     out << eb;
                 }
                 else
                 {
                     out << nl << "_System.Collections.Generic.IEnumerator<" << typeS
-                        << "> iceE = " << param << ".GetEnumerator();";
-                    out << nl << "while(iceE.MoveNext())";
+                        << "> e__ = " << param << ".GetEnumerator();";
+                    out << nl << "while(e__.MoveNext())";
                     out << sb;
-                    out << nl << stream << ".writeEnum((int)iceE.Current, " << en->maxValue() << ");";
+                    out << nl << stream << ".writeEnum((int)e__.Current, " << en->maxValue() << ");";
                     out << eb;
                 }
             }
             else
             {
-                out << nl << "for(int iceIx = 0; iceIx < " << param << '.' << limitID << "; ++iceIx)";
+                out << nl << "for(int ix__ = 0; ix__ < " << param << '.' << limitID << "; ++ix__)";
                 out << sb;
-                out << nl << stream << ".writeEnum((int)" << param << "[iceIx], " << en->maxValue() << ");";
+                out << nl << stream << ".writeEnum((int)" << param << "[ix__], " << en->maxValue() << ");";
                 out << eb;
             }
             out << eb;
@@ -1639,11 +1639,11 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         else
         {
             out << sb;
-            out << nl << "int iceSzx = " << stream << ".readAndCheckSeqSize(" <<
+            out << nl << "int szx__ = " << stream << ".readAndCheckSeqSize(" <<
                 static_cast<unsigned>(type->minWireSize()) << ");";
             if(isArray)
             {
-                out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+                out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
             }
             else if(isCustom)
             {
@@ -1651,27 +1651,27 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             }
             else if(isStack)
             {
-                out << nl << typeS << "[] " << param << "_tmp = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+                out << nl << typeS << "[] " << param << "__tmp = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
             }
             else if(isGeneric)
             {
                 out << nl << param << " = new _System.Collections.Generic." << genericType << "<" << typeS << ">(";
                 if(!isLinkedList)
                 {
-                    out << "iceSzx";
+                    out << "szx__";
                 }
                 out << ");";
             }
             else
             {
-                out << nl << param << " = new " << fixId(seq->scoped()) << "(iceSzx);";
+                out << nl << param << " = new " << fixId(seq->scoped()) << "(szx__);";
             }
-            out << nl << "for(int iceIx = 0; iceIx < iceSzx; ++iceIx)";
+            out << nl << "for(int ix__ = 0; ix__ < szx__; ++ix__)";
             out << sb;
             if(isArray || isStack)
             {
-                string v = isArray ? param : param + "_tmp";
-                out << nl << v << "[iceIx] = (" << typeS << ')' << stream << ".readEnum(" << en->maxValue() << ");";
+                string v = isArray ? param : param + "__tmp";
+                out << nl << v << "[ix__] = (" << typeS << ')' << stream << ".readEnum(" << en->maxValue() << ");";
             }
             else
             {
@@ -1681,9 +1681,9 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             out << eb;
             if(isStack)
             {
-                out << nl << "_System.Array.Reverse(" << param << "_tmp);";
+                out << nl << "_System.Array.Reverse(" << param << "__tmp);";
                 out << nl << param << " = new _System.Collections.Generic." << genericType << "<" << typeS << ">("
-                    << param << "_tmp);";
+                    << param << "__tmp);";
             }
             out << eb;
         }
@@ -1719,26 +1719,26 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
             if(isStack)
             {
                 out << nl << typeS << "[] " << param << "_tmp = " << param << ".ToArray();";
-                out << nl << "for(int iceIx = 0; iceIx < " << param << "_tmp.Length; ++iceIx)";
+                out << nl << "for(int ix__ = 0; ix__ < " << param << "_tmp.Length; ++ix__)";
                 out << sb;
-                out << nl << helperName << '.' << func << '(' << stream << ", " << param << "_tmp[iceIx]);";
+                out << nl << helperName << '.' << func << '(' << stream << ", " << param << "_tmp[ix__]);";
                 out << eb;
             }
             else
             {
                 out << nl << "_System.Collections.Generic.IEnumerator<" << typeS
-                    << "> iceE = " << param << ".GetEnumerator();";
-                out << nl << "while(iceE.MoveNext())";
+                    << "> e__ = " << param << ".GetEnumerator();";
+                out << nl << "while(e__.MoveNext())";
                 out << sb;
-                out << nl << helperName << '.' << func << '(' << stream << ", iceE.Current);";
+                out << nl << helperName << '.' << func << '(' << stream << ", e__.Current);";
                 out << eb;
             }
         }
         else
         {
-            out << nl << "for(int iceIx = 0; iceIx < " << param << '.' << limitID << "; ++iceIx)";
+            out << nl << "for(int ix__ = 0; ix__ < " << param << '.' << limitID << "; ++ix__)";
             out << sb;
-            out << nl << helperName << '.' << func << '(' << stream << ", " << param << "[iceIx]);";
+            out << nl << helperName << '.' << func << '(' << stream << ", " << param << "[ix__]);";
             out << eb;
         }
         out << eb;
@@ -1747,11 +1747,11 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
     {
         func = "read";
         out << sb;
-        out << nl << "int iceSzx = " << stream << ".readAndCheckSeqSize("
+        out << nl << "int szx__ = " << stream << ".readAndCheckSeqSize("
             << static_cast<unsigned>(type->minWireSize()) << ");";
         if(isArray)
         {
-            out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+            out << nl << param << " = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
         }
         else if(isCustom)
         {
@@ -1759,7 +1759,7 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         }
         else if(isStack)
         {
-            out << nl << typeS << "[] " << param << "_tmp = new " << toArrayAlloc(typeS + "[]", "iceSzx") << ";";
+            out << nl << typeS << "[] " << param << "__tmp = new " << toArrayAlloc(typeS + "[]", "szx__") << ";";
         }
         else if(isGeneric)
         {
@@ -1767,14 +1767,14 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         }
         else
         {
-            out << nl << param << " = new " << fixId(seq->scoped()) << "(iceSzx);";
+            out << nl << param << " = new " << fixId(seq->scoped()) << "(szx__);";
         }
-        out << nl << "for(int iceIx = 0; iceIx < iceSzx; ++iceIx)";
+        out << nl << "for(int ix__ = 0; ix__ < szx__; ++ix__)";
         out << sb;
         if(isArray || isStack)
         {
-            string v = isArray ? param : param + "_tmp";
-            out << nl << v << "[iceIx] = " << helperName << '.' << func << '(' << stream << ");";
+            string v = isArray ? param : param + "__tmp";
+            out << nl << v << "[ix__] = " << helperName << '.' << func << '(' << stream << ");";
         }
         else
         {
@@ -1783,9 +1783,9 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
         out << eb;
         if(isStack)
         {
-            out << nl << "_System.Array.Reverse(" << param << "_tmp);";
+            out << nl << "_System.Array.Reverse(" << param << "__tmp);";
             out << nl << param << " = new _System.Collections.Generic." << genericType << "<" << typeS << ">("
-                << param << "_tmp);";
+                << param << "__tmp);";
         }
         out << eb;
     }
@@ -1800,7 +1800,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
                                                               int tag,
                                                               bool marshal)
 {
-    string stream = marshal ? "iceOs" : "iceIs";
+    string stream = marshal ? "os__" : "is__";
 
     const TypePtr type = seq->type();
     const string typeS = typeToString(type);
@@ -1863,7 +1863,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
                 {
                     out << nl << stream << ".skipSize();";
                 }
-                string tmp = "iceTmpVal";
+                string tmp = "tmpVal__";
                 out << nl << seqS << ' ' << tmp << ';';
                 writeSequenceMarshalUnmarshalCode(out, seq, tmp, marshal, true);
                 out << nl << param << " = new Ice.Optional<" << seqS << ">(" << tmp << ");";
@@ -1885,9 +1885,9 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
                 out << nl << "if(" << param << ".HasValue && " << stream << ".writeOptional(" << tag << ", "
                     << getOptionalFormat(seq) << "))";
                 out << sb;
-                out << nl << "int icePos = " << stream << ".startSize();";
+                out << nl << "int pos__ = " << stream << ".startSize();";
                 writeSequenceMarshalUnmarshalCode(out, seq, param + ".Value", marshal, true);
-                out << nl << stream << ".endSize(icePos);";
+                out << nl << stream << ".endSize(pos__);";
                 out << eb;
             }
             else
@@ -1895,7 +1895,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
                 out << nl << "if(" << stream << ".readOptional(" << tag << ", " << getOptionalFormat(seq) << "))";
                 out << sb;
                 out << nl << stream << ".skip(4);";
-                string tmp = "iceTmpVal";
+                string tmp = "tmpVal__";
                 out << nl << seqS << ' ' << tmp << ';';
                 writeSequenceMarshalUnmarshalCode(out, seq, tmp, marshal, true);
                 out << nl << param << " = new Ice.Optional<" << seqS << ">(" << tmp << ");";
@@ -1925,7 +1925,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
             out << sb;
             if(st->isVariableLength())
             {
-                out << nl << "int icePos = " << stream << ".startSize();";
+                out << nl << "int pos__ = " << stream << ".startSize();";
             }
             else if(st->minWireSize() > 1)
             {
@@ -1935,7 +1935,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
             writeSequenceMarshalUnmarshalCode(out, seq, param + ".Value", marshal, true);
             if(st->isVariableLength())
             {
-                out << nl << stream << ".endSize(icePos);";
+                out << nl << stream << ".endSize(pos__);";
             }
             out << eb;
         }
@@ -1951,7 +1951,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
             {
                 out << nl << stream << ".skipSize();";
             }
-            string tmp = "iceTmpVal";
+            string tmp = "tmpVal__";
             out << nl << seqS << ' ' << tmp << ';';
             writeSequenceMarshalUnmarshalCode(out, seq, tmp, marshal, true);
             out << nl << param << " = new Ice.Optional<" << seqS << ">(" << tmp << ");";
@@ -1972,9 +1972,9 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
         out << nl << "if(" << param << ".HasValue && " << stream << ".writeOptional(" << tag << ", "
             << getOptionalFormat(seq) << "))";
         out << sb;
-        out << nl << "int icePos = " << stream << ".startSize();";
+        out << nl << "int pos__ = " << stream << ".startSize();";
         writeSequenceMarshalUnmarshalCode(out, seq, param + ".Value", marshal, true);
-        out << nl << stream << ".endSize(icePos);";
+        out << nl << stream << ".endSize(pos__);";
         out << eb;
     }
     else
@@ -1982,7 +1982,7 @@ Slice::CsGenerator::writeOptionalSequenceMarshalUnmarshalCode(Output& out,
         out << nl << "if(" << stream << ".readOptional(" << tag << ", " << getOptionalFormat(seq) << "))";
         out << sb;
         out << nl << stream << ".skip(4);";
-        string tmp = "iceTmpVal";
+        string tmp = "tmpVal__";
         out << nl << seqS << ' ' << tmp << ';';
         writeSequenceMarshalUnmarshalCode(out, seq, tmp, marshal, true);
         out << nl << param << " = new Ice.Optional<" << seqS << ">(" << tmp << ");";
@@ -2007,11 +2007,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, true);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "));";
         }
         return;
@@ -2026,11 +2026,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetByte(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetByte(\"" << param << "\");";
                 }
                 break;
             }
@@ -2038,11 +2038,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetBoolean(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetBoolean(\"" << param << "\");";
                 }
                 break;
             }
@@ -2050,11 +2050,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetInt16(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetInt16(\"" << param << "\");";
                 }
                 break;
             }
@@ -2062,11 +2062,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetInt32(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetInt32(\"" << param << "\");";
                 }
                 break;
             }
@@ -2074,11 +2074,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetInt64(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetInt64(\"" << param << "\");";
                 }
                 break;
             }
@@ -2086,11 +2086,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetSingle(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetSingle(\"" << param << "\");";
                 }
                 break;
             }
@@ -2098,11 +2098,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ");";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetDouble(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetDouble(\"" << param << "\");";
                 }
                 break;
             }
@@ -2110,12 +2110,12 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << " == null ? \"\" : " << param
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << " == null ? \"\" : " << param
                         << ");";
                 }
                 else
                 {
-                    out << nl << param << " = " << "iceInfo.GetString(\"" << param << "\");";
+                    out << nl << param << " = " << "info__.GetString(\"" << param << "\");";
                 }
                 break;
             }
@@ -2126,11 +2126,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
                 const string typeName = typeToString(type, false);
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
                 }
                 else
                 {
-                    out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof("
+                    out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof("
                         << typeName << "));";
                 }
                 break;
@@ -2139,12 +2139,12 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
             {
                 if(serialize)
                 {
-                    out << nl << "iceInfo.AddValue(\"" << param << "\", " << param
+                    out << nl << "info__.AddValue(\"" << param << "\", " << param
                         << ", typeof(Ice.ObjectPrxHelperBase));";
                 }
                 else
                 {
-                    out << nl << param << " = (Ice.ObjectPrx)iceInfo.GetValue(\"" << param
+                    out << nl << param << " = (Ice.ObjectPrx)info__.GetValue(\"" << param
                         << "\", typeof(Ice.ObjectPrxHelperBase));";
                 }
                 break;
@@ -2159,11 +2159,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, false);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "Helper));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "Helper));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "Helper));";
         }
         return;
@@ -2175,11 +2175,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, false);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "));";
         }
         return;
@@ -2191,11 +2191,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, false);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "));";
         }
         return;
@@ -2207,11 +2207,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, false);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "));";
         }
         return;
@@ -2223,11 +2223,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
         const string typeName = typeToString(type, false);
         if(serialize)
         {
-            out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+            out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
         }
         else
         {
-            out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+            out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
                 << "));";
         }
         return;
@@ -2238,11 +2238,11 @@ Slice::CsGenerator::writeSerializeDeserializeCode(Output &out,
     const string typeName = typeToString(type, false);
     if(serialize)
     {
-        out << nl << "iceInfo.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
+        out << nl << "info__.AddValue(\"" << param << "\", " << param << ", typeof(" << typeName << "));";
     }
     else
     {
-        out << nl << param << " = (" << typeName << ")iceInfo.GetValue(\"" << param << "\", typeof(" << typeName
+        out << nl << param << " = (" << typeName << ")info__.GetValue(\"" << param << "\", typeof(" << typeName
             << "));";
     }
 }
diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index 4871bc05ff7..9122c83a68b 100644
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -118,7 +118,7 @@ getEscapedParamName(const ParamDeclList& params, const string& name)
     {
         if((*i)->name() == name)
         {
-            return name + "_";
+            return name + "__";
         }
     }
     return name;
@@ -155,13 +155,13 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
     ParamDeclList optionals;
 
     string paramPrefix = "";
-    string returnValueS = "iceRet";
+    string returnValueS = "ret__";
 
     if(op && resultStruct)
     {
         if((op->returnType() && !params.empty()) || params.size() > 1)
         {
-            paramPrefix = "iceRet.";
+            paramPrefix = "ret__.";
             returnValueS = resultStructReturnValueName(params);
         }
     }
@@ -174,7 +174,7 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
         if(!marshal && isClassType(type))
         {
             patch = true;
-            param = "iceP_"+ (*pli)->name();
+            param = (*pli)->name() + "__PP";
             string typeS = typeToString(type);
             if((*pli)->optional())
             {
@@ -205,7 +205,7 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
     {
         ret = op->returnType();
         bool patch = false;
-        string param = "iceRet";
+        string param = "ret__";
         if(!marshal && isClassType(ret))
         {
             patch = true;
@@ -252,7 +252,7 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
     {
         if(checkReturnType && op->returnTag() < (*pli)->tag())
         {
-            const string param = !marshal && isClassType(ret) ? "iceRetPP.patch" : (paramPrefix + returnValueS);
+            const string param = !marshal && isClassType(ret) ? "ret__PP.patch" : (paramPrefix + returnValueS);
             writeOptionalMarshalUnmarshalCode(_out, ret, param, op->returnTag(), marshal);
             checkReturnType = false;
         }
@@ -263,7 +263,7 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
         bool patch = false;
         if(!marshal && isClassType(type))
         {
-            param = "iceP_" + (*pli)->name() + ".patch";
+            param = (*pli)->name() + "__PP.patch";
             patch = true;
         }
 
@@ -272,7 +272,7 @@ Slice::CsVisitor::writeMarshalUnmarshalParams(const ParamDeclList& params, const
 
     if(checkReturnType)
     {
-        const string param = !marshal && isClassType(ret) ? "iceRetPP.patch" : (paramPrefix + returnValueS);
+        const string param = !marshal && isClassType(ret) ? "ret__PP.patch" : (paramPrefix + returnValueS);
         writeOptionalMarshalUnmarshalCode(_out, ret, param, op->returnTag(), marshal);
     }
 }
@@ -282,13 +282,13 @@ Slice::CsVisitor::writePostUnmarshalParams(const ParamDeclList& params, const Op
 {
 
     string paramPrefix = "";
-    string returnValueS = "iceRet";
+    string returnValueS = "ret__";
 
     if(op)
     {
         if((op->returnType() && !params.empty()) || params.size() > 1)
         {
-            paramPrefix = "iceRet.";
+            paramPrefix = "ret__.";
             returnValueS = resultStructReturnValueName(op->outParameters());
         }
     }
@@ -297,14 +297,14 @@ Slice::CsVisitor::writePostUnmarshalParams(const ParamDeclList& params, const Op
     {
         if(isClassType((*pli)->type()))
         {
-            const string tmp = "iceP_" + (*pli)->name();
+            const string tmp = (*pli)->name() + "__PP";
             _out << nl << paramPrefix << fixId((*pli)->name()) << " = " << tmp << ".value;";
         }
     }
 
     if(op && op->returnType() && isClassType(op->returnType()))
     {
-        _out << nl << paramPrefix << returnValueS << " = iceRetPP.value;";
+        _out << nl << paramPrefix << returnValueS << " = ret__PP.value;";
     }
 }
 
@@ -330,7 +330,7 @@ Slice::CsVisitor::writeUnmarshalDataMember(const DataMemberPtr& member, const st
     string patcher;
     if(classType)
     {
-        patcher = "new IcePatcher(" + getStaticId(member->type()) + ", this";
+        patcher = "new Patcher__(" + getStaticId(member->type()) + ", this";
         if(needPatcher)
         {
             ostringstream ostr;
@@ -412,7 +412,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
         emitGeneratedCodeAttribute();
     }
 
-    _out << nl << "public static new readonly string[] s_iceIds = ";
+    _out << nl << "public static new readonly string[] ids__ = ";
     _out << sb;
     {
         StringList::const_iterator q = ids.begin();
@@ -432,9 +432,9 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
     {
         emitGeneratedCodeAttribute();
     }
-    _out << nl << "public override bool ice_isA(string s, Ice.Current iceCurrent = null)";
+    _out << nl << "public override bool ice_isA(string s, Ice.Current current__ = null)";
     _out << sb;
-    _out << nl << "return _System.Array.BinarySearch(s_iceIds, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;";
+    _out << nl << "return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;";
     _out << eb;
 
     _out << sp;
@@ -442,9 +442,9 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
     {
         emitGeneratedCodeAttribute();
     }
-    _out << nl << "public override string[] ice_ids(Ice.Current iceCurrent = null)";
+    _out << nl << "public override string[] ice_ids(Ice.Current current__ = null)";
     _out << sb;
-    _out << nl << "return s_iceIds;";
+    _out << nl << "return ids__;";
     _out << eb;
 
     _out << sp;
@@ -452,9 +452,9 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
     {
         emitGeneratedCodeAttribute();
     }
-    _out << nl << "public override string ice_id(Ice.Current iceCurrent = null)";
+    _out << nl << "public override string ice_id(Ice.Current current__ = null)";
     _out << sb;
-    _out << nl << "return s_iceIds[" << scopedPos << "];";
+    _out << nl << "return ids__[" << scopedPos << "];";
     _out << eb;
 
     _out << sp;
@@ -465,7 +465,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 
     _out << nl << "public static new string ice_staticId()";
     _out << sb;
-    _out << nl << "return s_iceIds[" << scopedPos << "];";
+    _out << nl << "return ids__[" << scopedPos << "];";
     _out << eb;
 
     _out << sp << nl << "#endregion"; // Slice type-related members
@@ -491,21 +491,21 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
             emitGeneratedCodeAttribute();
         }
         _out << nl << "public static _System.Threading.Tasks.Task<Ice.OutputStream>";
-        _out << nl << "iceD_" << opName << "(" << name << (p->isInterface() ? "" : "Disp_") << " iceObj, "
-             <<  "IceInternal.Incoming iceInS, Ice.Current iceCurrent)";
+        _out << nl << opName << "___(" << name << (p->isInterface() ? "" : "Disp_") << " obj__, "
+             <<  "IceInternal.Incoming inS__, Ice.Current current__)";
         _out << sb;
 
         TypePtr ret = op->returnType();
         ParamDeclList inParams = op->inParameters();
         ParamDeclList outParams = op->outParameters();
 
-        _out << nl << "Ice.ObjectImpl.iceCheckMode(" << sliceModeToIceMode(op->mode()) << ", iceCurrent.mode);";
+        _out << nl << "Ice.ObjectImpl.checkMode__(" << sliceModeToIceMode(op->mode()) << ", current__.mode);";
         if(!inParams.empty())
         {
             //
             // Unmarshal 'in' parameters.
             //
-            _out << nl << "var iceIs = iceInS.startReadParams();";
+            _out << nl << "var is__ = inS__.startReadParams();";
             for(ParamDeclList::const_iterator pli = inParams.begin(); pli != inParams.end(); ++pli)
             {
                 string param = fixId((*pli)->name());
@@ -539,55 +539,55 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
             writeMarshalUnmarshalParams(inParams, 0, false);
             if(op->sendsClasses(false))
             {
-                _out << nl << "iceIs.readPendingValues();";
+                _out << nl << "is__.readPendingValues();";
             }
-            _out << nl << "iceInS.endReadParams();";
+            _out << nl << "inS__.endReadParams();";
         }
         else
         {
-            _out << nl << "iceInS.readEmptyParams();";
+            _out << nl << "inS__.readEmptyParams();";
         }
 
         if(op->format() != DefaultFormat)
         {
-            _out << nl << "iceInS.setFormat(" << opFormatTypeToString(op) << ");";
+            _out << nl << "inS__.setFormat(" << opFormatTypeToString(op) << ");";
         }
 
         vector<string> inArgs;
         for(ParamDeclList::const_iterator pli = inParams.begin(); pli != inParams.end(); ++pli)
         {
-            inArgs.push_back(isClassType((*pli)->type()) ? ("iceP_" + (*pli)->name() + ".value") : fixId((*pli)->name()));
+            inArgs.push_back(isClassType((*pli)->type()) ? ((*pli)->name() + "__PP.value") : fixId((*pli)->name()));
         }
 
         const bool amd = p->hasMetaData("amd") || op->hasMetaData("amd");
         if(op->hasMarshaledResult())
         {
-            _out << nl << "return iceInS." << (amd ? "setMarshaledResultTask" : "setMarshaledResult");
-            _out << "(iceObj." << opName << (amd ? "Async" : "") << spar << inArgs << "iceCurrent" << epar << ");";
+            _out << nl << "return inS__." << (amd ? "setMarshaledResultTask" : "setMarshaledResult");
+            _out << "(obj__." << opName << (amd ? "Async" : "") << spar << inArgs << "current__" << epar << ");";
             _out << eb;
         }
         else if(amd)
         {
             string retS = resultType(op);
-            _out << nl << "return iceInS.setResultTask" << (retS.empty() ? "" : ('<' + retS + '>'));
-            _out << "(iceObj." << opName << "Async" << spar << inArgs << "iceCurrent" << epar;
+            _out << nl << "return inS__.setResultTask" << (retS.empty() ? "" : ('<' + retS + '>'));
+            _out << "(obj__." << opName << "Async" << spar << inArgs << "current__" << epar;
             if(!retS.empty())
             {
                 _out << ",";
                 _out.inc();
                 if(!ret && outParams.size() == 1)
                 {
-                    _out << nl << "(iceOs, " << fixId(outParams.front()->name()) << ") =>";
+                    _out << nl << "(os__, " << fixId(outParams.front()->name()) << ") =>";
                 }
                 else
                 {
-                    _out << nl << "(iceOs, iceRet) =>";
+                    _out << nl << "(os__, ret__) =>";
                 }
                 _out << sb;
                 writeMarshalUnmarshalParams(outParams, op, true, true);
                 if(op->returnsClasses(false))
                 {
-                    _out << nl << "iceOs.writePendingValues();";
+                    _out << nl << "os__.writePendingValues();";
                 }
                 _out << eb;
                 _out.dec();
@@ -609,32 +609,32 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
             _out << nl;
             if(ret)
             {
-                _out << "var iceRet = ";
+                _out << "var ret__ = ";
             }
-            _out << "iceObj." << fixId(opName, DotNet::ICloneable, true) << spar << inArgs;
+            _out << "obj__." << fixId(opName, DotNet::ICloneable, true) << spar << inArgs;
             for(ParamDeclList::const_iterator pli = outParams.begin(); pli != outParams.end(); ++pli)
             {
                 _out << "out " + fixId((*pli)->name());
             }
-            _out << "iceCurrent" << epar << ';';
+            _out << "current__" << epar << ';';
 
             //
             // Marshal 'out' parameters and return value.
             //
             if(!outParams.empty() || ret)
             {
-                _out << nl << "var iceOs = iceInS.startWriteParams();";
+                _out << nl << "var os__ = inS__.startWriteParams();";
                 writeMarshalUnmarshalParams(outParams, op, true);
                 if(op->returnsClasses(false))
                 {
-                    _out << nl << "iceOs.writePendingValues();";
+                    _out << nl << "os__.writePendingValues();";
                 }
-                _out << nl << "iceInS.endWriteParams(iceOs);";
-                _out << nl << "return iceInS.setResult(iceOs);";
+                _out << nl << "inS__.endWriteParams(os__);";
+                _out << nl << "return inS__.setResult(os__);";
             }
             else
             {
-                _out << nl << "return iceInS.setResult(iceInS.writeEmptyParams());";
+                _out << nl << "return inS__.setResult(inS__.writeEmptyParams());";
             }
             _out << eb;
         }
@@ -652,7 +652,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
         allOpNames.sort();
         allOpNames.unique();
 
-        _out << sp << nl << "private static string[] s_iceAll =";
+        _out << sp << nl << "private static string[] all__ =";
         _out << sb;
         for(StringList::const_iterator q = allOpNames.begin(); q != allOpNames.end();)
         {
@@ -670,13 +670,13 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
             emitGeneratedCodeAttribute();
         }
         _out << nl << "public override _System.Threading.Tasks.Task<Ice.OutputStream>";
-        _out << nl << "iceDispatch(IceInternal.Incoming iceInS, Ice.Current iceCurrent)";
+        _out << nl << "dispatch__(IceInternal.Incoming inS__, Ice.Current current__)";
         _out << sb;
-        _out << nl << "int pos = _System.Array.BinarySearch(s_iceAll, iceCurrent.operation, "
+        _out << nl << "int pos = _System.Array.BinarySearch(all__, current__.operation, "
             << "IceUtilInternal.StringUtil.OrdinalStringComparer);";
         _out << nl << "if(pos < 0)";
         _out << sb;
-        _out << nl << "throw new Ice.OperationNotExistException(iceCurrent.id, iceCurrent.facet, iceCurrent.operation);";
+        _out << nl << "throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);";
         _out << eb;
         _out << sp << nl << "switch(pos)";
         _out << sb;
@@ -689,19 +689,19 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
             _out << sb;
             if(opName == "ice_id")
             {
-                _out << nl << "return Ice.ObjectImpl.iceD_ice_id(this, iceInS, iceCurrent);";
+                _out << nl << "return Ice.ObjectImpl.ice_id___(this, inS__, current__);";
             }
             else if(opName == "ice_ids")
             {
-                _out << nl << "return Ice.ObjectImpl.iceD_ice_ids(this, iceInS, iceCurrent);";
+                _out << nl << "return Ice.ObjectImpl.ice_ids___(this, inS__, current__);";
             }
             else if(opName == "ice_isA")
             {
-                _out << nl << "return Ice.ObjectImpl.iceD_ice_isA(this, iceInS, iceCurrent);";
+                _out << nl << "return Ice.ObjectImpl.ice_isA___(this, inS__, current__);";
             }
             else if(opName == "ice_ping")
             {
-                _out << nl << "return Ice.ObjectImpl.iceD_ice_ping(this, iceInS, iceCurrent);";
+                _out << nl << "return Ice.ObjectImpl.ice_ping___(this, inS__, current__);";
             }
             else
             {
@@ -717,11 +717,11 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
                         assert(cl);
                         if(cl->scoped() == p->scoped())
                         {
-                            _out << nl << "return iceD_" << opName << "(this, iceInS, iceCurrent);";
+                            _out << nl << "return " << opName << "___(this, inS__, current__);";
                         }
                         else
                         {
-                            _out << nl << "return " << fixId(cl->scoped() + "Disp_") << ".iceD_" << opName << "(this, iceInS, iceCurrent);";
+                            _out << nl << "return " << fixId(cl->scoped() + "Disp_") << "." << opName << "___(this, inS__, current__);";
                         }
                         break;
                     }
@@ -731,7 +731,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
         }
         _out << eb;
         _out << sp << nl << "_System.Diagnostics.Debug.Assert(false);";
-        _out << nl << "throw new Ice.OperationNotExistException(iceCurrent.id, iceCurrent.facet, iceCurrent.operation);";
+        _out << nl << "throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);";
         _out << eb;
     }
 
@@ -786,11 +786,11 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
             emitGeneratedCodeAttribute();
         }
 
-        _out << nl << "public override void iceWrite(Ice.OutputStream iceOs)";
+        _out << nl << "public override void write__(Ice.OutputStream os__)";
         _out << sb;
-        _out << nl << "iceOs.startValue(m_iceSlicedData);";
-        _out << nl << "iceWriteImpl(iceOs);";
-        _out << nl << "iceOs.endValue();";
+        _out << nl << "os__.startValue(slicedData__);";
+        _out << nl << "writeImpl__(os__);";
+        _out << nl << "os__.endValue();";
         _out << eb;
 
         _out << sp;
@@ -798,11 +798,11 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
         {
             emitGeneratedCodeAttribute();
         }
-        _out << nl << "public override void iceRead(Ice.InputStream iceIs)";
+        _out << nl << "public override void read__(Ice.InputStream is__)";
         _out << sb;
-        _out << nl << "iceIs.startValue();";
-        _out << nl << "iceReadImpl(iceIs);";
-        _out << nl << "m_iceSlicedData = iceIs.endValue(true);";
+        _out << nl << "is__.startValue();";
+        _out << nl << "readImpl__(is__);";
+        _out << nl << "slicedData__ = is__.endValue(true);";
         _out << eb;
     }
 
@@ -811,9 +811,9 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
     {
         emitGeneratedCodeAttribute();
     }
-    _out << nl << "protected override void iceWriteImpl(Ice.OutputStream iceOs)";
+    _out << nl << "protected override void writeImpl__(Ice.OutputStream os__)";
     _out << sb;
-    _out << nl << "iceOs.startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");";
+    _out << nl << "os__.startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");";
     for(DataMemberList::const_iterator d = members.begin(); d != members.end(); ++d)
     {
         if(!(*d)->optional())
@@ -825,10 +825,10 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
     {
         writeMarshalDataMember(*d, fixId(*d, DotNet::ICloneable, true));
     }
-    _out << nl << "iceOs.endSlice();";
+    _out << nl << "os__.endSlice();";
     if(base)
     {
-        _out << nl << "base.iceWriteImpl(iceOs);";
+        _out << nl << "base.writeImpl__(os__);";
     }
     _out << eb;
 
@@ -844,9 +844,9 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
         {
             _out << "new ";
         }
-        _out << "class IcePatcher";
+        _out << "class Patcher__";
         _out << sb;
-        _out << sp << nl << "internal IcePatcher(string type, Ice.Value instance";
+        _out << sp << nl << "internal Patcher__(string type, Ice.Value instance";
 
         if(classMembers.size() > 1)
         {
@@ -973,9 +973,9 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
     {
         emitGeneratedCodeAttribute();
     }
-    _out << nl << "protected override void iceReadImpl(Ice.InputStream iceIs)";
+    _out << nl << "protected override void readImpl__(Ice.InputStream is__)";
     _out << sb;
-    _out << nl << "iceIs.startSlice();";
+    _out << nl << "is__.startSlice();";
     int patchIter = 0;
     const bool needCustomPatcher = classMembers.size() > 1;
     for(DataMemberList::const_iterator d = members.begin(); d != members.end(); ++d)
@@ -989,16 +989,16 @@ Slice::CsVisitor::writeMarshaling(const ClassDefPtr& p)
     {
         writeUnmarshalDataMember(*d, fixId(*d, DotNet::ICloneable, true), needCustomPatcher, patchIter);
     }
-    _out << nl << "iceIs.endSlice();";
+    _out << nl << "is__.endSlice();";
     if(base)
     {
-        _out << nl << "base.iceReadImpl(iceIs);";
+        _out << nl << "base.readImpl__(is__);";
     }
     _out << eb;
 
     if(preserved && !basePreserved)
     {
-        _out << sp << nl << "protected Ice.SlicedData m_iceSlicedData;";
+        _out << sp << nl << "protected Ice.SlicedData slicedData__;";
     }
 
     _out << sp << nl << "#endregion"; // Marshalling support
@@ -1066,7 +1066,7 @@ Slice::CsVisitor::getOutParams(const OperationPtr& op, bool returnParam, bool ou
         TypePtr ret = op->returnType();
         if(ret)
         {
-            params.push_back(typeToString(ret, op->returnIsOptional()) + " iceRet");
+            params.push_back(typeToString(ret, op->returnIsOptional()) + " ret__");
         }
     }
 
@@ -1335,7 +1335,7 @@ Slice::CsVisitor::writeDataMemberInitializers(const DataMemberList& members, int
             _out << nl << "this.";
             if(propertyMapping)
             {
-                _out << "_" << (*p)->name();
+                _out << (*p)->name() << "__prop";
             }
             else
             {
@@ -2475,7 +2475,7 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
                 const string paramName = fixId((*d)->name());
                 if(propertyMapping)
                 {
-                    _out << "_" << (*d)->name();
+                    _out << (*d)->name() << "__prop";
                 }
                 else
                 {
@@ -2504,18 +2504,18 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
     if(!p->isInterface() && !p->isLocal())
     {
         _out << sp << nl;
-        _out << nl << "public static new readonly string s_iceId = \""
+        _out << nl << "public static new readonly string static_id__ = \""
              << p->scoped() << "\";";
 
         _out << sp;
         _out << nl << "public static new string ice_staticId()";
         _out << sb;
-        _out << nl << "return s_iceId;";
+        _out << nl << "return static_id__;";
         _out << eb;
 
         _out << nl << "public override string ice_id()";
         _out << sb;
-        _out << nl << "return s_iceId;";
+        _out << nl << "return static_id__;";
         _out << eb;
 
         writeMarshaling(p);
@@ -2710,7 +2710,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     const bool hasDataMemberInitializers = requiresDataMemberInitializers(dataMembers);
     if(hasDataMemberInitializers)
     {
-        _out << sp << nl << "private void iceInitDM()";
+        _out << sp << nl << "private void initDM__()";
         _out << sb;
         writeDataMemberInitializers(dataMembers, DotNet::Exception);
         _out << eb;
@@ -2722,23 +2722,23 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     _out << sb;
     if(hasDataMemberInitializers)
     {
-        _out << nl << "iceInitDM();";
+        _out << nl << "initDM__();";
     }
     _out << eb;
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public " << name << "(_System.Exception iceEx) : base(iceEx)";
+    _out << nl << "public " << name << "(_System.Exception ex__) : base(ex__)";
     _out << sb;
     if(hasDataMemberInitializers)
     {
-        _out << nl << "iceInitDM();";
+        _out << nl << "initDM__();";
     }
     _out << eb;
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public " << name << "(_System.Runtime.Serialization.SerializationInfo iceInfo, "
-         << "_System.Runtime.Serialization.StreamingContext iceContext) : base(iceInfo, iceContext)";
+    _out << nl << "public " << name << "(_System.Runtime.Serialization.SerializationInfo info__, "
+         << "_System.Runtime.Serialization.StreamingContext context__) : base(info__, context__)";
     _out << sb;
     for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
@@ -2751,7 +2751,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     {
         if(!dataMembers.empty())
         {
-            _out << sp << nl << "private void iceInitDM" << spar << paramDecl << epar;
+            _out << sp << nl << "private void initDM__" << spar << paramDecl << epar;
             _out << sb;
             for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
             {
@@ -2771,14 +2771,14 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         _out << sb;
         if(!dataMembers.empty())
         {
-            _out << nl << "iceInitDM" << spar << paramNames << epar << ';';
+            _out << nl << "initDM__" << spar << paramNames << epar << ';';
         }
         _out << eb;
 
         vector<string> exceptionParam;
-        exceptionParam.push_back("iceEx");
+        exceptionParam.push_back("ex__");
         vector<string> exceptionDecl;
-        exceptionDecl.push_back("_System.Exception iceEx");
+        exceptionDecl.push_back("_System.Exception ex__");
         _out << sp;
         emitGeneratedCodeAttribute();
         _out << nl << "public " << name << spar << allParamDecl << exceptionDecl << epar << " : base" << spar;
@@ -2790,7 +2790,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         _out << sb;
         if(!dataMembers.empty())
         {
-            _out << nl << "iceInitDM" << spar << paramNames << epar << ';';
+            _out << nl << "initDM__" << spar << paramNames << epar << ';';
         }
         _out << eb;
     }
@@ -2812,37 +2812,37 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     _out << sb;
     if(p->base())
     {
-        _out << nl << "int iceH = base.GetHashCode();";
+        _out << nl << "int h__ = base.GetHashCode();";
     }
     else
     {
-        _out << nl << "int iceH = 5381;";
+        _out << nl << "int h__ = 5381;";
     }
-    _out << nl << "IceInternal.HashUtil.hashAdd(ref iceH, \"" << p->scoped() << "\");";
+    _out << nl << "IceInternal.HashUtil.hashAdd(ref h__, \"" << p->scoped() << "\");";
     writeMemberHashCode(dataMembers, DotNet::Exception);
-    _out << nl << "return iceH;";
+    _out << nl << "return h__;";
     _out << eb;
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public override bool Equals(object iceOther)";
+    _out << nl << "public override bool Equals(object other__)";
     _out << sb;
-    _out << nl << "if(iceOther == null)";
+    _out << nl << "if(other__ == null)";
     _out << sb;
     _out << nl << "return false;";
     _out << eb;
-    _out << nl << "if(object.ReferenceEquals(this, iceOther))";
+    _out << nl << "if(object.ReferenceEquals(this, other__))";
     _out << sb;
     _out << nl << "return true;";
     _out << eb;
-    _out << nl << name << " iceO = iceOther as " << name << ";";
-    _out << nl << "if(iceO == null)";
+    _out << nl << name << " o__ = other__ as " << name << ";";
+    _out << nl << "if(o__ == null)";
     _out << sb;
     _out << nl << "return false;";
     _out << eb;
     if(p->base())
     {
-        _out << nl << "if(!base.Equals(iceOther))";
+        _out << nl << "if(!base.Equals(other__))";
         _out << sb;
         _out << nl << "return false;";
         _out << eb;
@@ -2855,15 +2855,15 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     {
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public override void GetObjectData(_System.Runtime.Serialization.SerializationInfo iceInfo, "
-             << "_System.Runtime.Serialization.StreamingContext iceContext)";
+        _out << nl << "public override void GetObjectData(_System.Runtime.Serialization.SerializationInfo info__, "
+             << "_System.Runtime.Serialization.StreamingContext context__)";
         _out << sb;
         for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
             string name = fixId((*q)->name(), DotNet::Exception, false);
             writeSerializeDeserializeCode(_out, (*q)->type(), name, (*q)->optional(), (*q)->tag(), true);
         }
-        _out << sp << nl << "base.GetObjectData(iceInfo, iceContext);";
+        _out << sp << nl << "base.GetObjectData(info__, context__);";
         _out << eb;
     }
 
@@ -2873,16 +2873,16 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public static bool operator==(" << name << " iceLhs, " << name << " iceRhs)";
+    _out << nl << "public static bool operator==(" << name << " lhs__, " << name << " rhs__)";
     _out << sb;
-    _out << nl << "return Equals(iceLhs, iceRhs);";
+    _out << nl << "return Equals(lhs__, rhs__);";
     _out << eb;
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public static bool operator!=(" << name << " iceLhs, " << name << " iceRhs)";
+    _out << nl << "public static bool operator!=(" << name << " lhs__, " << name << " rhs__)";
     _out << sb;
-    _out << nl << "return !Equals(iceLhs, iceRhs);";
+    _out << nl << "return !Equals(lhs__, rhs__);";
     _out << eb;
 
     _out << sp << nl << "#endregion"; // Comparison members
@@ -2901,36 +2901,36 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         {
             _out << sp;
             emitGeneratedCodeAttribute();
-            _out << nl << "public override void iceWrite(Ice.OutputStream iceOs)";
+            _out << nl << "public override void write__(Ice.OutputStream os__)";
             _out << sb;
-            _out << nl << "iceOs.startException(m_iceSlicedData);";
-            _out << nl << "iceWriteImpl(iceOs);";
-            _out << nl << "iceOs.endException();";
+            _out << nl << "os__.startException(slicedData__);";
+            _out << nl << "writeImpl__(os__);";
+            _out << nl << "os__.endException();";
             _out << eb;
 
             _out << sp;
             emitGeneratedCodeAttribute();
-            _out << nl << "public override void iceRead(Ice.InputStream iceIs)";
+            _out << nl << "public override void read__(Ice.InputStream is__)";
             _out << sb;
-            _out << nl << "iceIs.startException();";
-            _out << nl << "iceReadImpl(iceIs);";
-            _out << nl << "m_iceSlicedData = iceIs.endException(true);";
+            _out << nl << "is__.startException();";
+            _out << nl << "readImpl__(is__);";
+            _out << nl << "slicedData__ = is__.endException(true);";
             _out << eb;
         }
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "protected override void iceWriteImpl(Ice.OutputStream iceOs)";
+        _out << nl << "protected override void writeImpl__(Ice.OutputStream os__)";
         _out << sb;
-        _out << nl << "iceOs.startSlice(\"" << scoped << "\", -1, " << (!base ? "true" : "false") << ");";
+        _out << nl << "os__.startSlice(\"" << scoped << "\", -1, " << (!base ? "true" : "false") << ");";
         for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
             writeMarshalDataMember(*q, fixId((*q)->name(), DotNet::Exception));
         }
-        _out << nl << "iceOs.endSlice();";
+        _out << nl << "os__.endSlice();";
         if(base)
         {
-            _out << nl << "base.iceWriteImpl(iceOs);";
+            _out << nl << "base.writeImpl__(os__);";
         }
         _out << eb;
 
@@ -2944,9 +2944,9 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             {
                 _out << "new ";
             }
-            _out << "class IcePatcher";
+            _out << "class Patcher__";
             _out << sb;
-            _out << sp << nl << "internal IcePatcher(string type, Ice.Exception instance";
+            _out << sp << nl << "internal Patcher__(string type, Ice.Exception instance";
             if(classMembers.size() > 1)
             {
                 _out << ", int member";
@@ -3082,9 +3082,9 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "protected override void iceReadImpl(Ice.InputStream iceIs)";
+        _out << nl << "protected override void readImpl__(Ice.InputStream is__)";
         _out << sb;
-        _out << nl << "iceIs.startSlice();";
+        _out << nl << "is__.startSlice();";
 
         int patchIter = 0;
         const bool needCustomPatcher = classMembers.size() > 1;
@@ -3092,10 +3092,10 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         {
             writeUnmarshalDataMember(*q, fixId((*q)->name(), DotNet::Exception), needCustomPatcher, patchIter);
         }
-        _out << nl << "iceIs.endSlice();";
+        _out << nl << "is__.endSlice();";
         if(base)
         {
-            _out << nl << "base.iceReadImpl(iceIs);";
+            _out << nl << "base.readImpl__(is__);";
         }
         _out << eb;
 
@@ -3103,7 +3103,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         {
             _out << sp;
             emitGeneratedCodeAttribute();
-            _out << nl << "public override bool iceUsesClasses()";
+            _out << nl << "public override bool usesClasses__()";
             _out << sb;
             _out << nl << "return true;";
             _out << eb;
@@ -3111,7 +3111,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(preserved && !basePreserved)
         {
-            _out << sp << nl << "protected Ice.SlicedData m_iceSlicedData;";
+            _out << sp << nl << "protected Ice.SlicedData slicedData__;";
         }
 
         _out << sp << nl << "#endregion"; // Marshalling support
@@ -3223,7 +3223,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         _out << nl << "this.";
         if(propertyMapping)
         {
-            _out << "_" << (*q)->name();
+            _out << (*q)->name() << "__prop";
         }
         else
         {
@@ -3255,41 +3255,41 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
     emitGeneratedCodeAttribute();
     _out << nl << "public override int GetHashCode()";
     _out << sb;
-    _out << nl << "int iceH = 5381;";
-    _out << nl << "IceInternal.HashUtil.hashAdd(ref iceH, \"" << p->scoped() << "\");";
+    _out << nl << "int h__ = 5381;";
+    _out << nl << "IceInternal.HashUtil.hashAdd(ref h__, \"" << p->scoped() << "\");";
     writeMemberHashCode(dataMembers, isClass ? DotNet::ICloneable : 0);
-    _out << nl << "return iceH;";
+    _out << nl << "return h__;";
     _out << eb;
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public override bool Equals(object iceOther)";
+    _out << nl << "public override bool Equals(object other__)";
     _out << sb;
     if(isClass)
     {
-        _out << nl << "if(object.ReferenceEquals(this, iceOther))";
+        _out << nl << "if(object.ReferenceEquals(this, other__))";
         _out << sb;
         _out << nl << "return true;";
         _out << eb;
     }
     if(isClass)
     {
-        _out << nl << "if(iceOther == null)";
+        _out << nl << "if(other__ == null)";
         _out << sb;
         _out << nl << "return false;";
         _out << eb;
-        _out << nl << "if(GetType() != iceOther.GetType())";
+        _out << nl << "if(GetType() != other__.GetType())";
     }
     else
     {
-        _out << nl << "if(!(iceOther is " << name << "))";
+        _out << nl << "if(!(other__ is " << name << "))";
     }
     _out << sb;
     _out << nl << "return false;";
     _out << eb;
     if(!dataMembers.empty())
     {
-        _out << nl << name << " iceO = (" << name << ")iceOther;";
+        _out << nl << name << " o__ = (" << name << ")other__;";
     }
     writeMemberEquals(dataMembers, isClass ? DotNet::ICloneable : 0);
     _out << nl << "return true;";
@@ -3301,16 +3301,16 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public static bool operator==(" << name << " iceLhs, " << name << " iceRhs)";
+    _out << nl << "public static bool operator==(" << name << " lhs__, " << name << " rhs__)";
     _out << sb;
-    _out << nl << "return Equals(iceLhs, iceRhs);";
+    _out << nl << "return Equals(lhs__, rhs__);";
     _out << eb;
 
     _out << sp;
     emitGeneratedCodeAttribute();
-    _out << nl << "public static bool operator!=(" << name << " iceLhs, " << name << " iceRhs)";
+    _out << nl << "public static bool operator!=(" << name << " lhs__, " << name << " rhs__)";
     _out << sb;
-    _out << nl << "return !Equals(iceLhs, iceRhs);";
+    _out << nl << "return !Equals(lhs__, rhs__);";
     _out << eb;
 
     _out << sp << nl << "#endregion"; // Comparison members
@@ -3321,7 +3321,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public void iceWrite(Ice.OutputStream iceOs)";
+        _out << nl << "public void write__(Ice.OutputStream os__)";
         _out << sb;
         for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
@@ -3333,9 +3333,9 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         {
             _out << sp;
             emitGeneratedCodeAttribute();
-            _out << nl << "public sealed class IcePatcher";
+            _out << nl << "public sealed class Patcher__";
             _out << sb;
-            _out << sp << nl << "internal IcePatcher(string type, " << name << " instance";
+            _out << sp << nl << "internal Patcher__(string type, " << name << " instance";
             if(classMembers.size() > 1)
             {
                 _out << ", int member";
@@ -3406,7 +3406,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public void iceRead(Ice.InputStream iceIs)";
+        _out << nl << "public void read__(Ice.InputStream is__)";
         _out << sb;
         int patchIter = 0;
         const bool needCustomPatcher = classMembers.size() > 1;
@@ -3419,37 +3419,37 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public static void write(Ice.OutputStream iceOs, " << name << " iceV)";
+        _out << nl << "public static void write(Ice.OutputStream os__, " << name << " v__)";
         _out << sb;
         if(isClass)
         {
-            _out << nl << "if(iceV == null)";
+            _out << nl << "if(v__ == null)";
             _out << sb;
-            _out << nl << "iceNullMarshalValue.iceWrite(iceOs);";
+            _out << nl << "nullMarshalValue__.write__(os__);";
             _out << eb;
             _out << nl << "else";
             _out << sb;
-            _out << nl << "iceV.iceWrite(iceOs);";
+            _out << nl << "v__.write__(os__);";
             _out << eb;
         }
         else
         {
-            _out << nl << "iceV.iceWrite(iceOs);";
+            _out << nl << "v__.write__(os__);";
         }
         _out << eb;
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public static " << name << " read(Ice.InputStream iceIs)";
+        _out << nl << "public static " << name << " read(Ice.InputStream is__)";
         _out << sb;
-        _out << nl << name << " iceV = new " << name << "();";
-        _out << nl << "iceV.iceRead(iceIs);";
-        _out << nl << "return iceV;";
+        _out << nl << name << " v__ = new " << name << "();";
+        _out << nl << "v__.read__(is__);";
+        _out << nl << "return v__;";
         _out << eb;
 
         if(isClass)
         {
-            _out << nl << nl << "private static readonly " << name << " iceNullMarshalValue = new " << name << "();";
+            _out << nl << nl << "private static readonly " << name << " nullMarshalValue__ = new " << name << "();";
         }
         _out << sp << nl << "#endregion"; // Marshalling support
     }
@@ -3497,18 +3497,18 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
         _out << nl << "public sealed class " << p->name() << "Helper";
         _out << sb;
         _out << sp;
-        _out << nl << "public static void write(Ice.OutputStream iceOs, " << name << " iceV)";
+        _out << nl << "public static void write(Ice.OutputStream os__, " << name << " v__)";
         _out << sb;
-        writeMarshalUnmarshalCode(_out, p, "iceV", true);
+        writeMarshalUnmarshalCode(_out, p, "v__", true);
         _out << eb;
 
         _out << sp;
         emitGeneratedCodeAttribute();
-        _out << nl << "public static " << name << " read(Ice.InputStream iceIs)";
+        _out << nl << "public static " << name << " read(Ice.InputStream is__)";
         _out << sb;
-        _out << nl << name << " iceV;";
-        writeMarshalUnmarshalCode(_out, p, "iceV", false);
-        _out << nl << "return iceV;";
+        _out << nl << name << " v__;";
+        writeMarshalUnmarshalCode(_out, p, "v__", false);
+        _out << nl << "return v__;";
         _out << eb;
 
         _out << eb;
@@ -3586,7 +3586,7 @@ Slice::Gen::TypesVisitor::visitDataMember(const DataMemberPtr& p)
     string dataMemberName;
     if(isProperty)
     {
-        dataMemberName = "_" + p->name();
+        dataMemberName = p->name() + "__prop";
     }
     else
     {
@@ -3647,7 +3647,7 @@ Slice::Gen::TypesVisitor::writeMemberHashCode(const DataMemberList& dataMembers,
 {
     for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
-        _out << nl << "IceInternal.HashUtil.hashAdd(ref iceH, " << fixId((*q)->name(), baseTypes);
+        _out << nl << "IceInternal.HashUtil.hashAdd(ref h__, " << fixId((*q)->name(), baseTypes);
         if((*q)->optional())
         {
             _out << ".Value";
@@ -3667,7 +3667,7 @@ Slice::Gen::TypesVisitor::writeMemberEquals(const DataMemberList& dataMembers, i
         {
             _out << nl << "if(" << memberName << " == null)";
             _out << sb;
-            _out << nl << "if(iceO." << memberName << " != null)";
+            _out << nl << "if(o__." << memberName << " != null)";
             _out << sb;
             _out << nl << "return false;";
             _out << eb;
@@ -3686,14 +3686,14 @@ Slice::Gen::TypesVisitor::writeMemberEquals(const DataMemberList& dataMembers, i
                     //
                     // Equals() for native arrays does not have value semantics.
                     //
-                    _out << nl << "if(!IceUtilInternal.Arrays.Equals(" << memberName << ", iceO." << memberName << "))";
+                    _out << nl << "if(!IceUtilInternal.Arrays.Equals(" << memberName << ", o__." << memberName << "))";
                 }
                 else if(isGeneric)
                 {
                     //
                     // Equals() for generic types does not have value semantics.
                     //
-                    _out << nl << "if(!IceUtilInternal.Collections.SequenceEquals(" << memberName << ", iceO."
+                    _out << nl << "if(!IceUtilInternal.Collections.SequenceEquals(" << memberName << ", o__."
                          << memberName << "))";
                 }
             }
@@ -3705,12 +3705,12 @@ Slice::Gen::TypesVisitor::writeMemberEquals(const DataMemberList& dataMembers, i
                     //
                     // Equals() for generic types does not have value semantics.
                     //
-                    _out << nl << "if(!IceUtilInternal.Collections.DictionaryEquals(" << memberName << ", iceO."
+                    _out << nl << "if(!IceUtilInternal.Collections.DictionaryEquals(" << memberName << ", o__."
                             << memberName << "))";
                 }
                 else
                 {
-                    _out << nl << "if(!" << memberName << ".Equals(iceO." << memberName << "))";
+                    _out << nl << "if(!" << memberName << ".Equals(o__." << memberName << "))";
                 }
             }
             _out << sb;
@@ -3720,7 +3720,7 @@ Slice::Gen::TypesVisitor::writeMemberEquals(const DataMemberList& dataMembers, i
         }
         else
         {
-            _out << nl << "if(!" << memberName << ".Equals(iceO." << memberName << "))";
+            _out << nl << "if(!" << memberName << ".Equals(o__." << memberName << "))";
             _out << sb;
             _out << nl << "return false;";
             _out << eb;
@@ -3852,21 +3852,21 @@ Slice::Gen::ResultVisitor::visitOperation(const OperationPtr& p)
         //
         // One shot constructor
         //
-        _out << nl << "public " << name << spar << getOutParams(p, true, false) << "Ice.Current iceCurrent" << epar;
+        _out << nl << "public " << name << spar << getOutParams(p, true, false) << "Ice.Current current__" << epar;
         _out << sb;
-        _out << nl << "iceOs = IceInternal.Incoming.createResponseOutputStream(iceCurrent);";
-        _out << nl << "iceOs.startEncapsulation(iceCurrent.encoding, " << opFormatTypeToString(p) << ");";
+        _out << nl << "os__ = IceInternal.Incoming.createResponseOutputStream(current__);";
+        _out << nl << "os__.startEncapsulation(current__.encoding, " << opFormatTypeToString(p) << ");";
         writeMarshalUnmarshalParams(outParams, p, true);
         if(p->returnsClasses(false))
         {
-            _out << nl << "iceOs.writePendingValues();";
+            _out << nl << "os__.writePendingValues();";
         }
-        _out << nl << "iceOs.endEncapsulation();";
+        _out << nl << "os__.endEncapsulation();";
         _out << eb;
         _out << sp;
         _out << nl << "public Ice.OutputStream getOutputStream(Ice.Current current)";
         _out << sb;
-        _out << nl << "if(iceOs == null)";
+        _out << nl << "if(os__ == null)";
         _out << sb;
         _out << nl << "return new " << name << spar;
         if(ret)
@@ -3879,10 +3879,10 @@ Slice::Gen::ResultVisitor::visitOperation(const OperationPtr& p)
         }
         _out << "current" << epar << ".getOutputStream(current);";
         _out << eb;
-        _out << nl << "return iceOs;";
+        _out << nl << "return os__;";
         _out << eb;
         _out << sp;
-        _out << nl << "private Ice.OutputStream iceOs;";
+        _out << nl << "private Ice.OutputStream os__;";
         _out << eb;
     }
 }
@@ -4119,7 +4119,7 @@ Slice::Gen::AsyncDelegateVisitor::visitOperation(const OperationPtr& p)
     _out << nl << "public delegate void " << delName << spar;
     if(p->returnType())
     {
-        _out << retS + " iceRet";
+        _out << retS + " ret__";
     }
     _out << paramDeclAMI << epar << ';';
 }
@@ -4270,8 +4270,8 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << eb;
 
     _out << sp;
-    _out << nl << "public " << name << "PrxHelper(_System.Runtime.Serialization.SerializationInfo iceInfo, "
-         << "_System.Runtime.Serialization.StreamingContext iceContext) : base(iceInfo, iceContext)";
+    _out << nl << "public " << name << "PrxHelper(_System.Runtime.Serialization.SerializationInfo info__, "
+         << "_System.Runtime.Serialization.StreamingContext context__) : base(info__, context__)";
     _out << sb;
     _out << eb;
 
@@ -4334,7 +4334,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             }
             else if(ret || outParams.size() > 1)
             {
-                _out << "var iceResult = ";
+                _out << "var result__ = ";
             }
             else
             {
@@ -4358,18 +4358,18 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             for(ParamDeclList::const_iterator i = outParams.begin(); i != outParams.end(); ++i)
             {
                 ParamDeclPtr param = *i;
-                _out << nl << fixId(param->name()) << " = iceResult." << fixId(param->name()) << ";";
+                _out << nl << fixId(param->name()) << " = result__." << fixId(param->name()) << ";";
             }
 
             if(ret)
             {
-                _out << nl << "return iceResult." << resultStructReturnValueName(outParams) << ";";
+                _out << nl << "return result__." << resultStructReturnValueName(outParams) << ";";
             }
         }
         _out << eb;
-        _out << nl << "catch(_System.AggregateException iceEx)";
+        _out << nl << "catch(_System.AggregateException ex__)";
         _out << sb;
-        _out << nl << "throw iceEx.InnerException;";
+        _out << nl << "throw ex__.InnerException;";
         _out << eb;
         _out << eb;
     }
@@ -4453,72 +4453,72 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             _out << "<" << returnTypeS << ">";
         }
         _out << " " << opName << "Async" << spar << paramsAMI
-             << "Ice.OptionalContext iceContext"
-             << "_System.IProgress<bool> iceProgress"
-             << "_System.Threading.CancellationToken iceCancel"
-             << "bool iceSynchronous" << epar;
+             << "Ice.OptionalContext context__"
+             << "_System.IProgress<bool> progress__"
+             << "_System.Threading.CancellationToken cancel__"
+             << "bool synchronous__" << epar;
         _out << sb;
 
         if(returnTypeS.empty())
         {
-            _out << nl << "var iceCompleted = "
-                 << "new IceInternal.OperationTaskCompletionCallback<object>(iceProgress, iceCancel);";
+            _out << nl << "var completed__ = "
+                 << "new IceInternal.OperationTaskCompletionCallback<object>(progress__, cancel__);";
         }
         else
         {
-            _out << nl << "var iceCompleted = "
-                 << "new IceInternal.OperationTaskCompletionCallback<" << returnTypeS << ">(iceProgress, iceCancel);";
+            _out << nl << "var completed__ = "
+                 << "new IceInternal.OperationTaskCompletionCallback<" << returnTypeS << ">(progress__, cancel__);";
         }
 
-        _out << nl << "iceI_" << opName << spar << argsAMI << "iceContext" << "iceSynchronous" << "iceCompleted"
+        _out << nl << opName << "___" << spar << argsAMI << "context__" << "synchronous__" << "completed__"
              << epar << ";";
-        _out << nl << "return iceCompleted.Task;";
+        _out << nl << "return completed__.Task;";
 
         _out << eb;
 
-        string flatName = "_" + opName + "_name";
+        string flatName = "__" + opName + "_name";
         _out << sp << nl << "private const string " << flatName << " = \"" << op->name() << "\";";
 
         //
         // Write the common invoke method
         //
         _out << sp << nl;
-        _out << "private void iceI_" << op->name() << spar << paramsAMI
-             << "_System.Collections.Generic.Dictionary<string, string> iceCtx"
-             << "bool iceSynchronous"
-             << "IceInternal.OutgoingAsyncCompletionCallback iceCompleted" << epar;
+        _out << "private void " << op->name() << "___" << spar << paramsAMI
+             << "_System.Collections.Generic.Dictionary<string, string> ctx__"
+             << "bool synchronous__"
+             << "IceInternal.OutgoingAsyncCompletionCallback completed__" << epar;
         _out << sb;
 
         if(op->returnsData())
         {
-            _out << nl << "iceCheckAsyncTwowayOnly(" << flatName << ");";
+            _out << nl << "checkAsyncTwowayOnly__(" << flatName << ");";
         }
 
         if(returnTypeS.empty())
         {
-            _out << nl << "var iceOutAsync = getOutgoingAsync<object>(iceCompleted);";
+            _out << nl << "var outAsync__ = getOutgoingAsync<object>(completed__);";
         }
         else
         {
-            _out << nl << "var iceOutAsync = getOutgoingAsync<" << returnTypeS << ">(iceCompleted);";
+            _out << nl << "var outAsync__ = getOutgoingAsync<" << returnTypeS << ">(completed__);";
         }
 
-        _out << nl << "iceOutAsync.invoke(";
+        _out << nl << "outAsync__.invoke(";
         _out.inc();
         _out << nl << flatName << ",";
         _out << nl << sliceModeToIceMode(op->sendMode()) << ",";
         _out << nl << opFormatTypeToString(op) << ",";
-        _out << nl << "iceCtx,";
-        _out << nl << "iceSynchronous";
+        _out << nl << "ctx__,";
+        _out << nl << "synchronous__";
         if(!inParams.empty())
         {
             _out << ",";
-            _out << nl << "write: (Ice.OutputStream iceOs) =>";
+            _out << nl << "write: (Ice.OutputStream os__) =>";
             _out << sb;
             writeMarshalUnmarshalParams(inParams, 0, true);
             if(op->sendsClasses(false))
             {
-                _out << nl << "iceOs.writePendingValues();";
+                _out << nl << "os__.writePendingValues();";
             }
             _out << eb;
         }
@@ -4554,11 +4554,11 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
         if(ret || !outParams.empty())
         {
             _out << ",";
-            _out << nl << "read: (Ice.InputStream iceIs) =>";
+            _out << nl << "read: (Ice.InputStream is__) =>";
             _out << sb;
             if(outParams.empty())
             {
-                _out << nl << returnTypeS << " iceRet";
+                _out << nl << returnTypeS << " ret__";
                 if(!op->returnIsOptional() && !isClassType(ret) && StructPtr::dynamicCast(ret))
                 {
                     _out << " = " << (isValueType(StructPtr::dynamicCast(ret)) ? ("new " + returnTypeS + "()") : "null");
@@ -4567,7 +4567,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             }
             else if(ret || outParams.size() > 1)
             {
-                _out << nl << returnTypeS << " iceRet = new " << returnTypeS << "();";
+                _out << nl << returnTypeS << " ret__ = new " << returnTypeS << "();";
             }
             else
             {
@@ -4583,7 +4583,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             writeMarshalUnmarshalParams(outParams, op, false, true);
             if(op->returnsClasses(false))
             {
-                _out << nl << "iceIs.readPendingValues();";
+                _out << nl << "is__.readPendingValues();";
             }
 
             writePostUnmarshalParams(outParams, op);
@@ -4594,7 +4594,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
             }
             else
             {
-                _out << nl << "return iceRet;";
+                _out << nl << "return ret__;";
             }
             _out << eb;
         }
@@ -4633,65 +4633,65 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
 
         _out << sp;
         _out << nl << "public Ice.AsyncResult<" << delType << "> begin_" << opName << spar << paramsAMI
-            << ("Ice.OptionalContext iceCtx = new Ice.OptionalContext()") << epar;
+            << ("Ice.OptionalContext ctx__ = new Ice.OptionalContext()") << epar;
         _out << sb;
-        _out << nl << "return begin_" << opName << spar << argsAMI << "iceCtx" << "null" << "null" << "false"
+        _out << nl << "return begin_" << opName << spar << argsAMI << "ctx__" << "null" << "null" << "false"
             << epar << ';';
         _out << eb;
 
         _out << sp;
         _out << nl << "public Ice.AsyncResult begin_" << opName << spar << paramsAMI
-            << "Ice.AsyncCallback iceCb" << "object iceCookie" << epar;
+            << "Ice.AsyncCallback cb__" << "object cookie__" << epar;
         _out << sb;
-        _out << nl << "return begin_" << opName << spar << argsAMI << "new Ice.OptionalContext()" << "iceCb"
-            << "iceCookie" << "false" << epar << ';';
+        _out << nl << "return begin_" << opName << spar << argsAMI << "new Ice.OptionalContext()" << "cb__"
+            << "cookie__" << "false" << epar << ';';
         _out << eb;
 
         _out << sp;
         _out << nl << "public Ice.AsyncResult begin_" << opName << spar << paramsAMI
-            << "Ice.OptionalContext iceCtx" << "Ice.AsyncCallback iceCb"
-            << "object iceCookie" << epar;
+            << "Ice.OptionalContext ctx__" << "Ice.AsyncCallback cb__"
+            << "object cookie__" << epar;
         _out << sb;
-        _out << nl << "return begin_" << opName << spar << argsAMI << "iceCtx" << "iceCb"
-            << "iceCookie" << "false" << epar << ';';
+        _out << nl << "return begin_" << opName << spar << argsAMI << "ctx__" << "cb__"
+            << "cookie__" << "false" << epar << ';';
         _out << eb;
 
         //
         // Write the end_ method.
         //
-        string flatName = "_" + opName + "_name";
+        string flatName = "__" + opName + "_name";
         _out << sp << nl << "public " << retS << " end_" << opName << spar << getOutParams(op, false, true)
-            << "Ice.AsyncResult iceR" << epar;
+            << "Ice.AsyncResult r__" << epar;
         _out << sb;
 
-        _out << nl << "var iceResultI = IceInternal.AsyncResultI.check(iceR, this, " << flatName << ");";
+        _out << nl << "var resultI__ = IceInternal.AsyncResultI.check(r__, this, " << flatName << ");";
 
         if(returnTypeS.empty())
         {
-            _out << nl << "((IceInternal.OutgoingAsyncT<object>)iceResultI.OutgoingAsync).iceResult(iceResultI.wait());";
+            _out << nl << "((IceInternal.OutgoingAsyncT<object>)resultI__.OutgoingAsync).result__(resultI__.wait());";
         }
         else
         {
-            _out << nl << "var iceOutgoing = (IceInternal.OutgoingAsyncT<" << returnTypeS << ">)iceResultI.OutgoingAsync;";
+            _out << nl << "var outgoing__ = (IceInternal.OutgoingAsyncT<" << returnTypeS << ">)resultI__.OutgoingAsync;";
             if(outParams.empty())
             {
-                _out << nl << "return iceOutgoing.iceResult(iceResultI.wait());";
+                _out << nl << "return outgoing__.result__(resultI__.wait());";
             }
             else if(!ret && outParams.size() == 1)
             {
-                _out << nl << fixId(outParams.front()->name()) << " = iceOutgoing.iceResult(iceResultI.wait());";
+                _out << nl << fixId(outParams.front()->name()) << " = outgoing__.result__(resultI__.wait());";
             }
             else
             {
-                _out << nl << "var iceResult = iceOutgoing.iceResult(iceResultI.wait());";
+                _out << nl << "var result__ = outgoing__.result__(resultI__.wait());";
                 for(ParamDeclList::const_iterator i = outParams.begin(); i != outParams.end(); ++i)
                 {
-                    _out << nl << fixId((*i)->name()) << " = iceResult." << fixId((*i)->name()) << ";";
+                    _out << nl << fixId((*i)->name()) << " = result__." << fixId((*i)->name()) << ";";
                 }
 
                 if(ret)
                 {
-                    _out << nl << "return iceResult." << resultStructReturnValueName(outParams) << ";";
+                    _out << nl << "return result__." << resultStructReturnValueName(outParams) << ";";
                 }
             }
         }
@@ -4702,12 +4702,12 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
         //
         _out << sp;
         _out << nl << "private Ice.AsyncResult<" << delType << "> begin_" << opName << spar << paramsAMI
-                << "_System.Collections.Generic.Dictionary<string, string> iceCtx"
-                << "Ice.AsyncCallback iceCompletedCallback" << "object iceCookie" << "bool iceSynchronous"
+                << "_System.Collections.Generic.Dictionary<string, string> ctx__"
+                << "Ice.AsyncCallback completedCallback__" << "object cookie__" << "bool synchronous__"
                 << epar;
         _out << sb;
 
-        _out << nl << "var iceCompleted = new IceInternal.OperationAsyncResultCompletionCallback<" << delType;
+        _out << nl << "var completed__ = new IceInternal.OperationAsyncResultCompletionCallback<" << delType;
         _out << ", " << (returnTypeS.empty() ? "object" : returnTypeS);
         _out << ">(";
 
@@ -4715,38 +4715,38 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
         // Write the completed callback
         //
         _out.inc();
-        _out << nl << "(" << delType << " iceCb, " << (returnTypeS.empty() ? "object" : returnTypeS) << " iceRet) =>";
+        _out << nl << "(" << delType << " cb__, " << (returnTypeS.empty() ? "object" : returnTypeS) << " ret__) =>";
         _out << sb;
-        _out << nl << "if(iceCb != null)";
+        _out << nl << "if(cb__ != null)";
         _out << sb;
-        _out << nl << "iceCb.Invoke" << spar;
+        _out << nl << "cb__.Invoke" << spar;
         if(ret && outParams.empty())
         {
-            _out << "iceRet";
+            _out << "ret__";
         }
         else if(ret || outParams.size() > 1)
         {
             if(ret)
             {
-                _out << "iceRet." + resultStructReturnValueName(outParams);
+                _out << "ret__." + resultStructReturnValueName(outParams);
             }
             for(ParamDeclList::const_iterator pli = outParams.begin(); pli != outParams.end(); ++pli)
             {
-                _out << "iceRet." + fixId((*pli)->name());
+                _out << "ret__." + fixId((*pli)->name());
             }
         }
         else if(!outParams.empty())
         {
-            _out << "iceRet";
+            _out << "ret__";
         }
         _out << epar << ';';
         _out << eb;
         _out << eb << ",";
-        _out << nl << "this, " << flatName << ", iceCookie, iceCompletedCallback);";
+        _out << nl << "this, " << flatName << ", cookie__, completedCallback__);";
 
         _out.dec();
-        _out << nl << "iceI_" << op->name() << spar << argsAMI << "iceCtx" << "iceSynchronous" << "iceCompleted" << epar << ";";
-        _out << nl << "return iceCompleted;";
+        _out << nl << op->name() << "___" << spar << argsAMI << "ctx__" << "synchronous__" << "completed__" << epar << ";";
+        _out << nl << "return completed__;";
         _out << eb;
     }
     _out << sp << nl << "#endregion"; // Asynchronous operations
@@ -4762,7 +4762,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << nl << "if((r == null) && b.ice_isA(ice_staticId()))";
     _out << sb;
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(b);";
+    _out << nl << "h.copyFrom__(b);";
     _out << nl << "r = h;";
     _out << eb;
     _out << nl << "return r;";
@@ -4779,7 +4779,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << nl << "if((r == null) && b.ice_isA(ice_staticId(), ctx))";
     _out << sb;
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(b);";
+    _out << nl << "h.copyFrom__(b);";
     _out << nl << "r = h;";
     _out << eb;
     _out << nl << "return r;";
@@ -4797,7 +4797,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << nl << "if(bb.ice_isA(ice_staticId()))";
     _out << sb;
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(bb);";
+    _out << nl << "h.copyFrom__(bb);";
     _out << nl << "return h;";
     _out << eb;
     _out << eb;
@@ -4821,7 +4821,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << nl << "if(bb.ice_isA(ice_staticId(), ctx))";
     _out << sb;
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(bb);";
+    _out << nl << "h.copyFrom__(bb);";
     _out << nl << "return h;";
     _out << eb;
     _out << eb;
@@ -4841,7 +4841,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << nl << "if(r == null)";
     _out << sb;
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(b);";
+    _out << nl << "h.copyFrom__(b);";
     _out << nl << "r = h;";
     _out << eb;
     _out << nl << "return r;";
@@ -4855,7 +4855,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     _out << eb;
     _out << nl << "Ice.ObjectPrx bb = b.ice_facet(f);";
     _out << nl << name << "PrxHelper h = new " << name << "PrxHelper();";
-    _out << nl << "h.iceCopyFrom(bb);";
+    _out << nl << "h.copyFrom__(bb);";
     _out << nl << "return h;";
     _out << eb;
 
@@ -4875,7 +4875,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
     assert(scopedIter != ids.end());
     StringList::difference_type scopedPos = IceUtilInternal::distance(firstIter, scopedIter);
 
-    _out << sp << nl << "public static readonly string[] s_iceIds =";
+    _out << sp << nl << "public static readonly string[] ids__ =";
     _out << sb;
 
     {
@@ -4893,25 +4893,25 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
 
     _out << sp << nl << "public static string ice_staticId()";
     _out << sb;
-    _out << nl << "return s_iceIds[" << scopedPos << "];";
+    _out << nl << "return ids__[" << scopedPos << "];";
     _out << eb;
 
     _out << sp << nl << "#endregion"; // Checked and unchecked cast operations
 
     _out << sp << nl << "#region Marshaling support";
 
-    _out << sp << nl << "public static void write(Ice.OutputStream iceOs, " << name << "Prx iceV)";
+    _out << sp << nl << "public static void write(Ice.OutputStream os__, " << name << "Prx v__)";
     _out << sb;
-    _out << nl << "iceOs.writeProxy(iceV);";
+    _out << nl << "os__.writeProxy(v__);";
     _out << eb;
 
-    _out << sp << nl << "public static " << name << "Prx read(Ice.InputStream iceIs)";
+    _out << sp << nl << "public static " << name << "Prx read(Ice.InputStream is__)";
     _out << sb;
-    _out << nl << "Ice.ObjectPrx proxy = iceIs.readProxy();";
+    _out << nl << "Ice.ObjectPrx proxy = is__.readProxy();";
     _out << nl << "if(proxy != null)";
     _out << sb;
     _out << nl << name << "PrxHelper result = new " << name << "PrxHelper();";
-    _out << nl << "result.iceCopyFrom(proxy);";
+    _out << nl << "result.copyFrom__(proxy);";
     _out << nl << "return result;";
     _out << eb;
     _out << nl << "return null;";
@@ -4946,16 +4946,16 @@ Slice::Gen::HelperVisitor::visitSequence(const SequencePtr& p)
     _out << nl << "public sealed class " << p->name() << "Helper";
     _out << sb;
 
-    _out << sp << nl << "public static void write(Ice.OutputStream iceOs, " << typeS << " iceV)";
+    _out << sp << nl << "public static void write(Ice.OutputStream os__, " << typeS << " v__)";
     _out << sb;
-    writeSequenceMarshalUnmarshalCode(_out, p, "iceV", true, false);
+    writeSequenceMarshalUnmarshalCode(_out, p, "v__", true, false);
     _out << eb;
 
-    _out << sp << nl << "public static " << typeS << " read(Ice.InputStream iceIs)";
+    _out << sp << nl << "public static " << typeS << " read(Ice.InputStream is__)";
     _out << sb;
-    _out << nl << typeS << " iceV;";
-    writeSequenceMarshalUnmarshalCode(_out, p, "iceV", false, false);
-    _out << nl << "return iceV;";
+    _out << nl << typeS << " v__;";
+    writeSequenceMarshalUnmarshalCode(_out, p, "v__", false, false);
+    _out << nl << "return v__;";
     _out << eb;
     _out << eb;
 
@@ -5030,23 +5030,23 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 
     _out << sp << nl << "public static void write(";
     _out.useCurrentPosAsIndent();
-    _out << "Ice.OutputStream iceOs,";
-    _out << nl << name << " iceV)";
+    _out << "Ice.OutputStream os__,";
+    _out << nl << name << " v__)";
     _out.restoreIndent();
     _out << sb;
-    _out << nl << "if(iceV == null)";
+    _out << nl << "if(v__ == null)";
     _out << sb;
-    _out << nl << "iceOs.writeSize(0);";
+    _out << nl << "os__.writeSize(0);";
     _out << eb;
     _out << nl << "else";
     _out << sb;
-    _out << nl << "iceOs.writeSize(iceV.Count);";
+    _out << nl << "os__.writeSize(v__.Count);";
     _out << nl << "foreach(_System.Collections.";
     _out << "Generic.KeyValuePair<" << keyS << ", " << valueS << ">";
-    _out << " iceE in iceV)";
+    _out << " e__ in v__)";
     _out << sb;
-    writeMarshalUnmarshalCode(_out, key, "iceE.Key", true);
-    writeMarshalUnmarshalCode(_out, value, "iceE.Value", true);
+    writeMarshalUnmarshalCode(_out, key, "e__.Key", true);
+    writeMarshalUnmarshalCode(_out, value, "e__.Value", true);
     _out << eb;
     _out << eb;
     _out << eb;
@@ -5055,9 +5055,9 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 
     if(hasClassValue)
     {
-        _out << sp << nl << "public sealed class IcePatcher";
+        _out << sp << nl << "public sealed class Patcher__";
         _out << sb;
-        _out << sp << nl << "internal IcePatcher(string type, " << name << " m, " << keyS << " key)";
+        _out << sp << nl << "internal Patcher__(string type, " << name << " m, " << keyS << " key)";
         _out << sb;
         _out << nl << "_type = type;";
         _out << nl << "_m = m;";
@@ -5089,56 +5089,56 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
         _out << eb;
     }
 
-    _out << sp << nl << "public static " << name << " read(Ice.InputStream iceIs)";
+    _out << sp << nl << "public static " << name << " read(Ice.InputStream is__)";
     _out << sb;
-    _out << nl << "int iceSz = iceIs.readSize();";
-    _out << nl << name << " iceR = new " << name << "();";
-    _out << nl << "for(int iceI = 0; iceI < iceSz; ++iceI)";
+    _out << nl << "int sz__ = is__.readSize();";
+    _out << nl << name << " r__ = new " << name << "();";
+    _out << nl << "for(int i__ = 0; i__ < sz__; ++i__)";
     _out << sb;
-    _out << nl << keyS << " iceK;";
+    _out << nl << keyS << " k__;";
     StructPtr st = StructPtr::dynamicCast(key);
     if(st)
     {
         if(isValueType(st))
         {
-            _out << nl << "iceK = new " << typeToString(key) << "();";
+            _out << nl << "k__ = new " << typeToString(key) << "();";
         }
         else
         {
-            _out << nl << "iceK = null;";
+            _out << nl << "k__ = null;";
         }
     }
-    writeMarshalUnmarshalCode(_out, key, "iceK", false);
+    writeMarshalUnmarshalCode(_out, key, "k__", false);
 
     string patcher;
     if(hasClassValue)
     {
-        patcher = "new IcePatcher(" + getStaticId(value) + ", iceR, iceK).patch";
+        patcher = "new Patcher__(" + getStaticId(value) + ", r__, k__).patch";
     }
     else
     {
-        _out << nl << valueS << " iceV;";
+        _out << nl << valueS << " v__;";
 
         StructPtr st = StructPtr::dynamicCast(value);
         if(st)
         {
             if(isValueType(st))
             {
-                _out << nl << "iceV = new " << typeToString(value) << "();";
+                _out << nl << "v__ = new " << typeToString(value) << "();";
             }
             else
             {
-                _out << nl << "iceV = null;";
+                _out << nl << "v__ = null;";
             }
         }
     }
-    writeMarshalUnmarshalCode(_out, value, hasClassValue ? patcher : "iceV", false);
+    writeMarshalUnmarshalCode(_out, value, hasClassValue ? patcher : "v__", false);
     if(!hasClassValue)
     {
-        _out << nl << "iceR[iceK] = iceV;";
+        _out << nl << "r__[k__] = v__;";
     }
     _out << eb;
-    _out << nl << "return iceR;";
+    _out << nl << "return r__;";
     _out << eb;
 
     _out << eb;
@@ -5391,7 +5391,7 @@ Slice::Gen::BaseImplVisitor::writeOperation(const OperationPtr& op, bool comment
         {
             _out << "override ";
         }
-        _out << "void " << opName << "_async" << spar << pDecl << "Ice.Current iceCurrent = null" << epar;
+        _out << "void " << opName << "_async" << spar << pDecl << "Ice.Current current__ = null" << epar;
 
         if(comment)
         {
@@ -5402,7 +5402,7 @@ Slice::Gen::BaseImplVisitor::writeOperation(const OperationPtr& op, bool comment
         _out << sb;
         if(ret)
         {
-            _out << nl << typeToString(ret) << " iceRet = " << writeValue(ret) << ';';
+            _out << nl << typeToString(ret) << " ret__ = " << writeValue(ret) << ';';
         }
         for(ParamDeclList::const_iterator i = params.begin(); i != params.end(); ++i)
         {
@@ -5413,10 +5413,10 @@ Slice::Gen::BaseImplVisitor::writeOperation(const OperationPtr& op, bool comment
                 _out << nl << typeToString(type) << ' ' << name << " = " << writeValue(type) << ';';
             }
         }
-        _out << nl << "iceCb.ice_response" << spar;
+        _out << nl << "cb__.ice_response" << spar;
         if(ret)
         {
-            _out << "iceRet";
+            _out << "ret__";
         }
         for(ParamDeclList::const_iterator i = params.begin(); i != params.end(); ++i)
         {
@@ -5440,7 +5440,7 @@ Slice::Gen::BaseImplVisitor::writeOperation(const OperationPtr& op, bool comment
         _out << retS << ' ' << fixId(opName, DotNet::ICloneable, true) << spar << pDecls;
         if(!cl->isLocal())
         {
-            _out << "Ice.Current iceCurrent = null";
+            _out << "Ice.Current current__ = null";
         }
         _out << epar;
         if(comment)
diff --git a/csharp/src/Glacier2/Application.cs b/csharp/src/Glacier2/Application.cs
index f610d150b11..dd7caf4f806 100644
--- a/csharp/src/Glacier2/Application.cs
+++ b/csharp/src/Glacier2/Application.cs
@@ -190,7 +190,7 @@ public abstract class Application : Ice.Application
             throw new SessionNotExistException();
         }
 
-        lock(s_iceMutex)
+        lock(mutex__)
         {
             if(_adapter == null)
             {
@@ -235,21 +235,21 @@ public abstract class Application : Ice.Application
         // Reset internal state variables from Ice.Application. The
         // remainder are reset at the end of this method.
         //
-        s_iceCallbackInProgress = false;
-        s_iceDestroyed = false;
-        s_iceInterrupted = false;
+        callbackInProgress__ = false;
+        destroyed__ = false;
+        interrupted__ = false;
 
         bool restart = false;
         status = 0;
 
         try
         {
-            s_iceCommunicator = Ice.Util.initialize(ref args, initData);
+            communicator__ = Ice.Util.initialize(ref args, initData);
 
             _router = Glacier2.RouterPrxHelper.uncheckedCast(communicator().getDefaultRouter());
             if(_router == null)
             {
-                Ice.Util.getProcessLogger().error(s_iceAppName + ": no Glacier2 router configured");
+                Ice.Util.getProcessLogger().error(appName__ + ": no Glacier2 router configured");
                 status = 1;
             }
             else
@@ -257,7 +257,7 @@ public abstract class Application : Ice.Application
                 //
                 // The default is to destroy when a signal is received.
                 //
-                if(s_iceSignalPolicy == Ice.SignalPolicy.HandleSignals)
+                if(signalPolicy__ == Ice.SignalPolicy.HandleSignals)
                 {
                     destroyOnInterrupt();
                 }
@@ -353,28 +353,28 @@ public abstract class Application : Ice.Application
         // (post-run), it would not make sense to release a held
         // signal to run shutdown or destroy.
         //
-        if(s_iceSignalPolicy == Ice.SignalPolicy.HandleSignals)
+        if(signalPolicy__ == Ice.SignalPolicy.HandleSignals)
         {
             ignoreInterrupt();
         }
 
-        lock(s_iceMutex)
+        lock(mutex__)
         {
-            while(s_iceCallbackInProgress)
+            while(callbackInProgress__)
             {
-                System.Threading.Monitor.Wait(s_iceMutex);
+                System.Threading.Monitor.Wait(mutex__);
             }
 
-            if(s_iceDestroyed)
+            if(destroyed__)
             {
-                s_iceCommunicator = null;
+                communicator__ = null;
             }
             else
             {
-                s_iceDestroyed = true;
+                destroyed__ = true;
                 //
-                // And s_iceCommunicator != null, meaning will be
-                // destroyed next, s_iceDestroyed = true also ensures that
+                // And communicator__ != null, meaning will be
+                // destroyed next, destroyed__ = true also ensures that
                 // any remaining callback won't do anything
                 //
             }
@@ -409,11 +409,11 @@ public abstract class Application : Ice.Application
             _router = null;
         }
 
-        if(s_iceCommunicator != null)
+        if(communicator__ != null)
         {
             try
             {
-                s_iceCommunicator.destroy();
+                communicator__.destroy();
             }
             catch(Ice.LocalException ex)
             {
@@ -425,12 +425,12 @@ public abstract class Application : Ice.Application
                 Ice.Util.getProcessLogger().error("unknown exception:\n" + ex.ToString());
                 status = 1;
             }
-            s_iceCommunicator = null;
+            communicator__ = null;
         }
 
         //
         // Reset internal state. We cannot reset the Application state
-        // here, since s_iceDestroyed must remain true until we re-run
+        // here, since destroyed__ must remain true until we re-run
         // this method.
         //
         _adapter = null;
diff --git a/csharp/src/Ice/Application.cs b/csharp/src/Ice/Application.cs
index 4140d203abe..b41ba4e8996 100644
--- a/csharp/src/Ice/Application.cs
+++ b/csharp/src/Ice/Application.cs
@@ -95,7 +95,7 @@ namespace Ice
         /// <param name="signalPolicy">Determines how to respond to signals.</param>
         public Application(SignalPolicy signalPolicy)
         {
-            s_iceSignalPolicy = signalPolicy;
+            signalPolicy__ = signalPolicy;
         }
 
         /// <summary>
@@ -135,7 +135,7 @@ namespace Ice
         {
             if(Util.getProcessLogger() is ConsoleLoggerI)
             {
-                Util.setProcessLogger(new ConsoleLoggerI(s_iceAppName));
+                Util.setProcessLogger(new ConsoleLoggerI(appName__));
             }
 
             InitializationData initData = new InitializationData();
@@ -178,10 +178,10 @@ namespace Ice
         {
             if(Util.getProcessLogger() is ConsoleLoggerI)
             {
-                Util.setProcessLogger(new ConsoleLoggerI(s_iceAppName));
+                Util.setProcessLogger(new ConsoleLoggerI(appName__));
             }
 
-            if(s_iceCommunicator != null)
+            if(communicator__ != null)
             {
                 Util.getProcessLogger().error("only one instance of the Application class can be used");
                 return 1;
@@ -214,13 +214,13 @@ namespace Ice
                 Util.getProcessLogger().error("unknown exception:\n" + ex);
                 return 1;
             }
-            s_iceAppName = initData.properties.getPropertyWithDefault("Ice.ProgramName", s_iceAppName);
+            appName__ = initData.properties.getPropertyWithDefault("Ice.ProgramName", appName__);
 
-            s_iceNohup = initData.properties.getPropertyAsInt("Ice.Nohup") > 0;
+            nohup__ = initData.properties.getPropertyAsInt("Ice.Nohup") > 0;
             _application = this;
 
             int status;
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
                 if(IceInternal.AssemblyUtil.platform_ == IceInternal.AssemblyUtil.Platform.Windows)
                 {
@@ -254,7 +254,7 @@ namespace Ice
         /// <returns>The name of the application.</returns>
         public static string appName()
         {
-            return s_iceAppName;
+            return appName__;
         }
 
         /// <summary>
@@ -265,7 +265,7 @@ namespace Ice
         /// <returns>The communicator for the application.</returns>
         public static Communicator communicator()
         {
-            return s_iceCommunicator;
+            return communicator__;
         }
 
         /// <summary>
@@ -274,14 +274,14 @@ namespace Ice
         /// </summary>
         public static void destroyOnInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback == _holdCallback)
                     {
-                        s_iceReleased = true;
-                        System.Threading.Monitor.Pulse(s_iceMutex);
+                        released__ = true;
+                        System.Threading.Monitor.Pulse(mutex__);
                     }
                     _callback = _destroyCallback;
                 }
@@ -298,14 +298,14 @@ namespace Ice
         /// </summary>
         public static void shutdownOnInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback == _holdCallback)
                     {
-                        s_iceReleased = true;
-                        System.Threading.Monitor.Pulse(s_iceMutex);
+                        released__ = true;
+                        System.Threading.Monitor.Pulse(mutex__);
                     }
                     _callback = _shutdownCallback;
                 }
@@ -322,14 +322,14 @@ namespace Ice
         /// </summary>
         public static void ignoreInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback == _holdCallback)
                     {
-                        s_iceReleased = true;
-                        System.Threading.Monitor.Pulse(s_iceMutex);
+                        released__ = true;
+                        System.Threading.Monitor.Pulse(mutex__);
                     }
                     _callback = null;
                 }
@@ -347,14 +347,14 @@ namespace Ice
         /// </summary>
         public static void callbackOnInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback == _holdCallback)
                     {
-                        s_iceReleased = true;
-                        System.Threading.Monitor.Pulse(s_iceMutex);
+                        released__ = true;
+                        System.Threading.Monitor.Pulse(mutex__);
                     }
                     _callback = _userCallback;
                 }
@@ -371,14 +371,14 @@ namespace Ice
         /// </summary>
         public static void holdInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback != _holdCallback)
                     {
                         _previousCallback = _callback;
-                        s_iceReleased = false;
+                        released__ = false;
                         _callback = _holdCallback;
                     }
                     // else, we were already holding signals
@@ -397,22 +397,22 @@ namespace Ice
         /// </summary>
         public static void releaseInterrupt()
         {
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
-                lock(s_iceMutex)
+                lock(mutex__)
                 {
                     if(_callback == _holdCallback)
                     {
                         //
                         // Note that it's very possible no signal is held;
                         // in this case the callback is just replaced and
-                        // setting s_iceReleased to true and signalling this
+                        // setting released__ to true and signalling this
                         // will do no harm.
                         //
 
-                        s_iceReleased = true;
+                        released__ = true;
                         _callback = _previousCallback;
-                        System.Threading.Monitor.Pulse(s_iceMutex);
+                        System.Threading.Monitor.Pulse(mutex__);
                     }
                     // Else nothing to release.
                 }
@@ -431,9 +431,9 @@ namespace Ice
         /// <returns>True if a signal caused the communicator to shut down; false otherwise.</returns>
         public static bool interrupted()
         {
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                return s_iceInterrupted;
+                return interrupted__;
             }
         }
 
@@ -453,13 +453,13 @@ namespace Ice
                     Util.setProcessLogger(new ConsoleLoggerI(initData.properties.getProperty("Ice.ProgramName")));
                 }
 
-                s_iceCommunicator = Util.initialize(ref args, initData);
-                s_iceDestroyed = false;
+                communicator__ = Util.initialize(ref args, initData);
+                destroyed__ = false;
 
                 //
                 // The default is to destroy when a signal is received.
                 //
-                if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+                if(signalPolicy__ == SignalPolicy.HandleSignals)
                 {
                     destroyOnInterrupt();
                 }
@@ -482,38 +482,38 @@ namespace Ice
             // (post-run), it would not make sense to release a held
             // signal to run shutdown or destroy.
             //
-            if(s_iceSignalPolicy == SignalPolicy.HandleSignals)
+            if(signalPolicy__ == SignalPolicy.HandleSignals)
             {
                 ignoreInterrupt();
             }
 
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                while(s_iceCallbackInProgress)
+                while(callbackInProgress__)
                 {
-                    System.Threading.Monitor.Wait(s_iceMutex);
+                    System.Threading.Monitor.Wait(mutex__);
                 }
-                if(s_iceDestroyed)
+                if(destroyed__)
                 {
-                    s_iceCommunicator = null;
+                    communicator__ = null;
                 }
                 else
                 {
-                    s_iceDestroyed = true;
+                    destroyed__ = true;
                     //
-                    // s_iceCommunicator != null means that it will be destroyed
-                    // next; s_iceDestroyed == true ensures that any
+                    // communicator__ != null means that it will be destroyed
+                    // next; destroyed__ == true ensures that any
                     // remaining callback won't do anything
                     //
                 }
                 _application = null;
             }
 
-            if(s_iceCommunicator != null)
+            if(communicator__ != null)
             {
                 try
                 {
-                    s_iceCommunicator.destroy();
+                    communicator__.destroy();
                 }
                 catch(Ice.Exception ex)
                 {
@@ -525,7 +525,7 @@ namespace Ice
                     Util.getProcessLogger().error("unknown exception:\n" + ex);
                     status = 1;
                 }
-                s_iceCommunicator = null;
+                communicator__ = null;
             }
 
             return status;
@@ -538,7 +538,7 @@ namespace Ice
         {
             Callback callback;
 
-            lock(s_iceMutex)
+            lock(mutex__)
             {
                 callback = _callback;
             }
@@ -562,14 +562,14 @@ namespace Ice
         private static void holdInterruptCallback(int sig)
         {
             Callback callback = null;
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                while(!s_iceReleased)
+                while(!released__)
                 {
-                    System.Threading.Monitor.Wait(s_iceMutex);
+                    System.Threading.Monitor.Wait(mutex__);
                 }
 
-                if(s_iceDestroyed)
+                if(destroyed__)
                 {
                     //
                     // Being destroyed by main thread
@@ -591,86 +591,86 @@ namespace Ice
         //
         private static void destroyOnInterruptCallback(int sig)
         {
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                if(s_iceDestroyed)
+                if(destroyed__)
                 {
                     //
                     // Being destroyed by main thread
                     //
                     return;
                 }
-                if(s_iceNohup && sig == SIGHUP)
+                if(nohup__ && sig == SIGHUP)
                 {
                     return;
                 }
 
-                Debug.Assert(!s_iceCallbackInProgress);
-                s_iceCallbackInProgress = true;
-                s_iceInterrupted = true;
-                s_iceDestroyed = true;
+                Debug.Assert(!callbackInProgress__);
+                callbackInProgress__ = true;
+                interrupted__ = true;
+                destroyed__ = true;
             }
 
             try
             {
-                Debug.Assert(s_iceCommunicator != null);
-                s_iceCommunicator.destroy();
+                Debug.Assert(communicator__ != null);
+                communicator__.destroy();
             }
             catch(System.Exception ex)
             {
                 Util.getProcessLogger().error("(while destroying in response to signal " + sig + "):\n" + ex);
             }
 
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                s_iceCallbackInProgress = false;
-                System.Threading.Monitor.Pulse(s_iceMutex);
+                callbackInProgress__ = false;
+                System.Threading.Monitor.Pulse(mutex__);
             }
         }
 
         private static void shutdownOnInterruptCallback(int sig)
         {
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                if(s_iceDestroyed)
+                if(destroyed__)
                 {
                     //
                     // Being destroyed by main thread
                     //
                     return;
                 }
-                if(s_iceNohup && sig == SIGHUP)
+                if(nohup__ && sig == SIGHUP)
                 {
                     return;
                 }
 
-                Debug.Assert(!s_iceCallbackInProgress);
-                s_iceCallbackInProgress = true;
-                s_iceInterrupted = true;
+                Debug.Assert(!callbackInProgress__);
+                callbackInProgress__ = true;
+                interrupted__ = true;
             }
 
             try
             {
-                Debug.Assert(s_iceCommunicator != null);
-                s_iceCommunicator.shutdown();
+                Debug.Assert(communicator__ != null);
+                communicator__.shutdown();
             }
             catch(System.Exception ex)
             {
                 Util.getProcessLogger().error("(while shutting down in response to signal " + sig + "):\n" + ex);
             }
 
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                s_iceCallbackInProgress = false;
-                System.Threading.Monitor.Pulse(s_iceMutex);
+                callbackInProgress__ = false;
+                System.Threading.Monitor.Pulse(mutex__);
             }
         }
 
         private static void userCallbackOnInterruptCallback(int sig)
         {
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                if(s_iceDestroyed)
+                if(destroyed__)
                 {
                     //
                     // Being destroyed by main thread
@@ -679,9 +679,9 @@ namespace Ice
                 }
                 // For SIGHUP the user callback is always called. It can
                 // decide what to do.
-                Debug.Assert(!s_iceCallbackInProgress);
-                s_iceCallbackInProgress = true;
-                s_iceInterrupted = true;
+                Debug.Assert(!callbackInProgress__);
+                callbackInProgress__ = true;
+                interrupted__ = true;
             }
 
             try
@@ -694,20 +694,20 @@ namespace Ice
                 Util.getProcessLogger().error("(while interrupting in response to signal " + sig + "):\n" + ex);
             }
 
-            lock(s_iceMutex)
+            lock(mutex__)
             {
-                s_iceCallbackInProgress = false;
-                System.Threading.Monitor.Pulse(s_iceMutex);
+                callbackInProgress__ = false;
+                System.Threading.Monitor.Pulse(mutex__);
             }
         }
 
-        protected static object s_iceMutex = new object();
-        protected static bool s_iceCallbackInProgress = false;
-        protected static bool s_iceDestroyed = false;
-        protected static bool s_iceInterrupted = false;
-        protected static bool s_iceReleased = false;
-        protected static bool s_iceNohup = false;
-        protected static SignalPolicy s_iceSignalPolicy = SignalPolicy.HandleSignals;
+        protected static object mutex__ = new object();
+        protected static bool callbackInProgress__ = false;
+        protected static bool destroyed__ = false;
+        protected static bool interrupted__ = false;
+        protected static bool released__ = false;
+        protected static bool nohup__ = false;
+        protected static SignalPolicy signalPolicy__ = SignalPolicy.HandleSignals;
 
         private delegate void Callback(int sig);
         private static readonly Callback _destroyCallback = new Callback(destroyOnInterruptCallback);
@@ -722,8 +722,8 @@ namespace Ice
         // We use FriendlyName instead of Process.GetCurrentProcess().ProcessName because the latter
         // is terribly slow. (It takes around 1 second!)
         //
-        protected static string s_iceAppName = AppDomain.CurrentDomain.FriendlyName;
-        protected static Communicator s_iceCommunicator;
+        protected static string appName__ = AppDomain.CurrentDomain.FriendlyName;
+        protected static Communicator communicator__;
         private static Application _application;
 
         private static int SIGHUP;
diff --git a/csharp/src/Ice/CommunicatorI.cs b/csharp/src/Ice/CommunicatorI.cs
index cae993b8ee2..d4f54bdca1d 100644
--- a/csharp/src/Ice/CommunicatorI.cs
+++ b/csharp/src/Ice/CommunicatorI.cs
@@ -173,7 +173,7 @@ namespace Ice
         {
             var completed = new FlushBatchTaskCompletionCallback(progress, cancel);
             var outgoing = new CommunicatorFlushBatchAsync(instance_, completed);
-            outgoing.invoke(_flushBatchRequests_name);
+            outgoing.invoke(__flushBatchRequests_name);
             return completed.Task;
         }
 
@@ -182,7 +182,7 @@ namespace Ice
             return begin_flushBatchRequests(null, null);
         }
 
-        private const string _flushBatchRequests_name = "flushBatchRequests";
+        private const string __flushBatchRequests_name = "flushBatchRequests";
 
         private class CommunicatorFlushBatchCompletionCallback : AsyncResultCompletionCallback
         {
@@ -216,9 +216,9 @@ namespace Ice
 
         public AsyncResult begin_flushBatchRequests(AsyncCallback cb, object cookie)
         {
-            var result = new CommunicatorFlushBatchCompletionCallback(this, instance_, _flushBatchRequests_name, cookie, cb);
+            var result = new CommunicatorFlushBatchCompletionCallback(this, instance_, __flushBatchRequests_name, cookie, cb);
             var outgoing = new CommunicatorFlushBatchAsync(instance_, result);
-            outgoing.invoke(_flushBatchRequests_name);
+            outgoing.invoke(__flushBatchRequests_name);
             return result;
         }
 
@@ -226,12 +226,12 @@ namespace Ice
         {
             if(result != null && result.getCommunicator() != this)
             {
-                const string msg = "Communicator for call to end_" + _flushBatchRequests_name +
+                const string msg = "Communicator for call to end_" + __flushBatchRequests_name +
                                    " does not match communicator that was used to call corresponding begin_" +
-                                   _flushBatchRequests_name + " method";
+                                   __flushBatchRequests_name + " method";
                 throw new ArgumentException(msg);
             }
-            AsyncResultI.check(result, _flushBatchRequests_name).wait();
+            AsyncResultI.check(result, __flushBatchRequests_name).wait();
         }
 
         public ObjectPrx createAdmin(ObjectAdapter adminAdapter, Identity adminIdentity)
diff --git a/csharp/src/Ice/ConnectRequestHandler.cs b/csharp/src/Ice/ConnectRequestHandler.cs
index 76fadf29fd8..d53aef9513a 100644
--- a/csharp/src/Ice/ConnectRequestHandler.cs
+++ b/csharp/src/Ice/ConnectRequestHandler.cs
@@ -281,7 +281,7 @@ namespace IceInternal
                 _requestHandler = new ConnectionRequestHandler(_reference, _connection, _compress);
                 foreach(Ice.ObjectPrxHelperBase prx in _proxies)
                 {
-                    prx.iceUpdateRequestHandler(this, _requestHandler);
+                    prx.updateRequestHandler__(this, _requestHandler);
                 }
             }
 
diff --git a/csharp/src/Ice/ConnectionI.cs b/csharp/src/Ice/ConnectionI.cs
index 4475bb107a2..5e0ab3afbf3 100644
--- a/csharp/src/Ice/ConnectionI.cs
+++ b/csharp/src/Ice/ConnectionI.cs
@@ -520,16 +520,16 @@ namespace Ice
         {
             var completed = new FlushBatchTaskCompletionCallback(progress, cancel);
             var outgoing = new ConnectionFlushBatchAsync(this, _instance, completed);
-            outgoing.invoke(_flushBatchRequests_name);
+            outgoing.invoke(__flushBatchRequests_name);
             return completed.Task;
         }
 
         public AsyncResult begin_flushBatchRequests(AsyncCallback cb = null, object cookie = null)
         {
             var result = new ConnectionFlushBatchCompletionCallback(this, _communicator, _instance,
-                                                                    _flushBatchRequests_name, cookie, cb);
+                                                                    __flushBatchRequests_name, cookie, cb);
             var outgoing = new ConnectionFlushBatchAsync(this, _instance, result);
-            outgoing.invoke(_flushBatchRequests_name);
+            outgoing.invoke(__flushBatchRequests_name);
             return result;
         }
 
@@ -537,15 +537,15 @@ namespace Ice
         {
             if(r != null && r.getConnection() != this)
             {
-                const string msg = "Connection for call to end_" + _flushBatchRequests_name +
+                const string msg = "Connection for call to end_" + __flushBatchRequests_name +
                                    " does not match connection that was used to call corresponding begin_" +
-                                   _flushBatchRequests_name + " method";
+                                   __flushBatchRequests_name + " method";
                 throw new ArgumentException(msg);
             }
-            AsyncResultI.check(r, _flushBatchRequests_name).wait();
+            AsyncResultI.check(r, __flushBatchRequests_name).wait();
         }
 
-        private const string _flushBatchRequests_name = "flushBatchRequests";
+        private const string __flushBatchRequests_name = "flushBatchRequests";
 
         public void setCloseCallback(CloseCallback callback)
         {
@@ -1071,10 +1071,10 @@ namespace Ice
                                 }
 
                                 ProtocolVersion pv  = new ProtocolVersion();
-                                pv.iceRead(_readStream);
+                                pv.read__(_readStream);
                                 IceInternal.Protocol.checkSupportedProtocol(pv);
                                 EncodingVersion ev = new EncodingVersion();
-                                ev.iceRead(_readStream);
+                                ev.read__(_readStream);
                                 IceInternal.Protocol.checkSupportedProtocolEncoding(ev);
 
                                 _readStream.readByte(); // messageType
@@ -1949,8 +1949,8 @@ namespace Ice
                 //
                 OutputStream os = new OutputStream(_instance, Util.currentProtocolEncoding);
                 os.writeBlob(IceInternal.Protocol.magic);
-                Ice.Util.currentProtocol.iceWrite(os);
-                Ice.Util.currentProtocolEncoding.iceWrite(os);
+                Ice.Util.currentProtocol.write__(os);
+                Ice.Util.currentProtocolEncoding.write__(os);
                 os.writeByte(IceInternal.Protocol.closeConnectionMsg);
                 os.writeByte(_compressionSupported ? (byte)1 : (byte)0);
                 os.writeInt(IceInternal.Protocol.headerSize); // Message size.
@@ -1981,8 +1981,8 @@ namespace Ice
             {
                 OutputStream os = new OutputStream(_instance, Util.currentProtocolEncoding);
                 os.writeBlob(IceInternal.Protocol.magic);
-                Ice.Util.currentProtocol.iceWrite(os);
-                Ice.Util.currentProtocolEncoding.iceWrite(os);
+                Ice.Util.currentProtocol.write__(os);
+                Ice.Util.currentProtocolEncoding.write__(os);
                 os.writeByte(IceInternal.Protocol.validateConnectionMsg);
                 os.writeByte((byte)0);
                 os.writeInt(IceInternal.Protocol.headerSize); // Message size.
@@ -2027,8 +2027,8 @@ namespace Ice
                     if(_writeStream.size() == 0)
                     {
                         _writeStream.writeBlob(IceInternal.Protocol.magic);
-                        Ice.Util.currentProtocol.iceWrite(_writeStream);
-                        Ice.Util.currentProtocolEncoding.iceWrite(_writeStream);
+                        Ice.Util.currentProtocol.write__(_writeStream);
+                        Ice.Util.currentProtocolEncoding.write__(_writeStream);
                         _writeStream.writeByte(IceInternal.Protocol.validateConnectionMsg);
                         _writeStream.writeByte((byte)0); // Compression status (always zero for validate connection).
                         _writeStream.writeInt(IceInternal.Protocol.headerSize); // Message size.
@@ -2098,11 +2098,11 @@ namespace Ice
                     }
 
                     ProtocolVersion pv  = new ProtocolVersion();
-                    pv.iceRead(_readStream);
+                    pv.read__(_readStream);
                     IceInternal.Protocol.checkSupportedProtocol(pv);
 
                     EncodingVersion ev = new EncodingVersion();
-                    ev.iceRead(_readStream);
+                    ev.read__(_readStream);
                     IceInternal.Protocol.checkSupportedProtocolEncoding(ev);
 
                     byte messageType = _readStream.readByte();
diff --git a/csharp/src/Ice/DispatchInterceptor.cs b/csharp/src/Ice/DispatchInterceptor.cs
index 9cf3347f606..a571f356c2c 100644
--- a/csharp/src/Ice/DispatchInterceptor.cs
+++ b/csharp/src/Ice/DispatchInterceptor.cs
@@ -31,7 +31,7 @@ namespace Ice
         dispatch(Request request);
 
         public override System.Threading.Tasks.Task<Ice.OutputStream>
-        iceDispatch(IceInternal.Incoming inc, Current current)
+        dispatch__(IceInternal.Incoming inc, Current current)
         {
             return dispatch(inc);
         }
diff --git a/csharp/src/Ice/Exception.cs b/csharp/src/Ice/Exception.cs
index 5d1b5ad7d43..e07e9209a9c 100644
--- a/csharp/src/Ice/Exception.cs
+++ b/csharp/src/Ice/Exception.cs
@@ -202,27 +202,27 @@ namespace Ice
         /// <param name="context">Contains contextual information about the source or destination.</param>
         protected UserException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
-        public virtual void iceWrite(OutputStream iceOs)
+        public virtual void write__(OutputStream os__)
         {
-            iceOs.startException(null);
-            iceWriteImpl(iceOs);
-            iceOs.endException();
+            os__.startException(null);
+            writeImpl__(os__);
+            os__.endException();
         }
 
-        public virtual void iceRead(InputStream iceIs)
+        public virtual void read__(InputStream is__)
         {
-            iceIs.startException();
-            iceReadImpl(iceIs);
-            iceIs.endException(false);
+            is__.startException();
+            readImpl__(is__);
+            is__.endException(false);
         }
 
-        public virtual bool iceUsesClasses()
+        public virtual bool usesClasses__()
         {
             return false;
         }
 
-        protected abstract void iceWriteImpl(OutputStream iceOs);
-        protected abstract void iceReadImpl(InputStream iceIs);
+        protected abstract void writeImpl__(OutputStream os__);
+        protected abstract void readImpl__(InputStream is__);
     }
 }
 
diff --git a/csharp/src/Ice/Incoming.cs b/csharp/src/Ice/Incoming.cs
index 36b0f721892..9df6f1625c7 100644
--- a/csharp/src/Ice/Incoming.cs
+++ b/csharp/src/Ice/Incoming.cs
@@ -110,7 +110,7 @@ namespace IceInternal
             //
             // Read the current.
             //
-            _current.id.iceRead(_is);
+            _current.id.read__(_is);
 
             //
             // For compatibility with the old FacetPath.
@@ -211,7 +211,7 @@ namespace IceInternal
 
             try
             {
-                Task<Ice.OutputStream> task = _servant.iceDispatch(this, _current);
+                Task<Ice.OutputStream> task = _servant.dispatch__(this, _current);
                 if(task == null)
                 {
                     completed(null, false);
@@ -605,7 +605,7 @@ namespace IceInternal
                     {
                         Debug.Assert(false);
                     }
-                    ex.id.iceWrite(_os);
+                    ex.id.write__(_os);
 
                     //
                     // For compatibility with the old FacetPath.
diff --git a/csharp/src/Ice/InputStream.cs b/csharp/src/Ice/InputStream.cs
index 4d0676023c6..0f9de976656 100644
--- a/csharp/src/Ice/InputStream.cs
+++ b/csharp/src/Ice/InputStream.cs
@@ -558,7 +558,7 @@ namespace Ice
             _encapsStack.sz = sz;
 
             EncodingVersion encoding = new EncodingVersion();
-            encoding.iceRead(this);
+            encoding.read__(this);
             Protocol.checkSupportedEncoding(encoding); // Make sure the encoding is supported.
             _encapsStack.setEncoding(encoding);
 
@@ -627,7 +627,7 @@ namespace Ice
             }
 
             var encoding = new EncodingVersion();
-            encoding.iceRead(this);
+            encoding.read__(this);
             if(encoding.Equals(Util.Encoding_1_0))
             {
                 if(sz != 6)
@@ -664,7 +664,7 @@ namespace Ice
             }
 
             encoding = new EncodingVersion();
-            encoding.iceRead(this);
+            encoding.read__(this);
             _buf.b.position(_buf.b.position() - 6);
 
             byte[] v = new byte[sz];
@@ -710,7 +710,7 @@ namespace Ice
                 throw new UnmarshalOutOfBoundsException();
             }
             EncodingVersion encoding = new EncodingVersion();
-            encoding.iceRead(this);
+            encoding.read__(this);
             try
             {
                 _buf.b.position(_buf.b.position() + sz - 6);
@@ -2900,7 +2900,7 @@ namespace Ice
                 //
                 // Read the instance.
                 //
-                v.iceRead(_stream);
+                v.read__(_stream);
 
                 if(_patchMap != null)
                 {
@@ -3073,7 +3073,7 @@ namespace Ice
                     //
                     if(userEx != null)
                     {
-                        userEx.iceRead(_stream);
+                        userEx.read__(_stream);
                         if(usesClasses)
                         {
                             readPendingValues();
@@ -3382,7 +3382,7 @@ namespace Ice
                     //
                     if(userEx != null)
                     {
-                        userEx.iceRead(_stream);
+                        userEx.read__(_stream);
                         throw userEx;
 
                         // Never reached.
@@ -4018,12 +4018,12 @@ namespace Ice
         /// <param name="inStream">The input stream to read from.</param>
         public abstract void read(InputStream inStream);
 
-        public override void iceWrite(OutputStream os)
+        public override void write__(OutputStream os)
         {
             Debug.Assert(false);
         }
 
-        public override void iceRead(InputStream istr)
+        public override void read__(InputStream istr)
         {
             read(istr);
         }
diff --git a/csharp/src/Ice/LocatorInfo.cs b/csharp/src/Ice/LocatorInfo.cs
index 50b2c8b6a14..50eccbbb5fe 100644
--- a/csharp/src/Ice/LocatorInfo.cs
+++ b/csharp/src/Ice/LocatorInfo.cs
@@ -30,7 +30,7 @@ namespace IceInternal
                 EndpointI[] endpoints = null;
                 if(proxy != null)
                 {
-                    Reference r = ((Ice.ObjectPrxHelperBase)proxy).iceReference();
+                    Reference r = ((Ice.ObjectPrxHelperBase)proxy).reference__();
                     if(_ref.isWellKnown() && !Protocol.isSupported(_ref.getEncoding(), r.getEncoding()))
                     {
                         //
@@ -163,7 +163,7 @@ namespace IceInternal
                     EndpointI[] endpoints = null;
                     if(_proxy != null)
                     {
-                        Reference r = ((Ice.ObjectPrxHelperBase)_proxy).iceReference();
+                        Reference r = ((Ice.ObjectPrxHelperBase)_proxy).reference__();
                         if(!r.isIndirect())
                         {
                             endpoints = r.getEndpoints();
@@ -697,7 +697,7 @@ namespace IceInternal
         finishRequest(Reference @ref, List<Reference> wellKnownRefs, Ice.ObjectPrx proxy, bool notRegistered)
         {
             Ice.ObjectPrxHelperBase @base = proxy as Ice.ObjectPrxHelperBase;
-            if(proxy == null || @base.iceReference().isIndirect())
+            if(proxy == null || @base.reference__().isIndirect())
             {
                 //
                 // Remove the cached references of well-known objects for which we tried
@@ -711,10 +711,10 @@ namespace IceInternal
 
             if(!@ref.isWellKnown())
             {
-                if(proxy != null && !@base.iceReference().isIndirect())
+                if(proxy != null && !@base.reference__().isIndirect())
                 {
                     // Cache the adapter endpoints.
-                    _table.addAdapterEndpoints(@ref.getAdapterId(), @base.iceReference().getEndpoints());
+                    _table.addAdapterEndpoints(@ref.getAdapterId(), @base.reference__().getEndpoints());
                 }
                 else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache.
                 {
@@ -729,10 +729,10 @@ namespace IceInternal
             }
             else
             {
-                if(proxy != null && !@base.iceReference().isWellKnown())
+                if(proxy != null && !@base.reference__().isWellKnown())
                 {
                     // Cache the well-known object reference.
-                    _table.addObjectReference(@ref.getIdentity(), @base.iceReference());
+                    _table.addObjectReference(@ref.getIdentity(), @base.reference__());
                 }
                 else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache.
                 {
@@ -762,7 +762,7 @@ namespace IceInternal
         {
             public LocatorKey(Ice.LocatorPrx prx)
             {
-                Reference r = ((Ice.ObjectPrxHelperBase)prx).iceReference();
+                Reference r = ((Ice.ObjectPrxHelperBase)prx).reference__();
                 _id = r.getIdentity();
                 _encoding = r.getEncoding();
             }
diff --git a/csharp/src/Ice/Object.cs b/csharp/src/Ice/Object.cs
index 6d325a00f62..0b888955616 100644
--- a/csharp/src/Ice/Object.cs
+++ b/csharp/src/Ice/Object.cs
@@ -69,7 +69,7 @@ namespace Ice
         /// <returns>The task if dispatched asynchronously, null otherwise.</returns>
         Task<Ice.OutputStream> ice_dispatch(Request request);
 
-        Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inc, Current current);
+        Task<Ice.OutputStream> dispatch__(IceInternal.Incoming inc, Current current);
     }
 
     /// <summary>
@@ -94,7 +94,7 @@ namespace Ice
             return MemberwiseClone();
         }
 
-        public static readonly string[] s_iceIds =
+        public static readonly string[] ids__ =
         {
             "::Ice::Object"
         };
@@ -107,19 +107,19 @@ namespace Ice
         /// <returns>The return value is true if s is ::Ice::Object.</returns>
         public virtual bool ice_isA(string s, Current current = null)
         {
-            return s.Equals(s_iceIds[0]);
+            return s.Equals(ids__[0]);
         }
 
-        public static Task<Ice.OutputStream> iceD_ice_isA(Ice.Object iceObj, IceInternal.Incoming iceInS, Current iceCurrent)
+        public static Task<Ice.OutputStream> ice_isA___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
         {
-            InputStream iceIs = iceInS.startReadParams();
-            var iceId = iceIs.readString();
-            iceInS.endReadParams();
-            var iceRet = iceObj.ice_isA(iceId, iceCurrent);
-            var iceOs = iceInS.startWriteParams();
-            iceOs.writeBool(iceRet);
-            iceInS.endWriteParams(iceOs);
-            iceInS.setResult(iceOs);
+            InputStream is__ = inS__.startReadParams();
+            var __id = is__.readString();
+            inS__.endReadParams();
+            var __ret = __obj.ice_isA(__id, __current);
+            var os__ = inS__.startWriteParams();
+            os__.writeBool(__ret);
+            inS__.endWriteParams(os__);
+            inS__.setResult(os__);
             return null;
         }
 
@@ -132,11 +132,11 @@ namespace Ice
             // Nothing to do.
         }
 
-        public static Task<Ice.OutputStream> iceD_ice_ping(Ice.Object iceObj, IceInternal.Incoming iceInS, Current iceCurrent)
+        public static Task<Ice.OutputStream> ice_ping___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
         {
-            iceInS.readEmptyParams();
-            iceObj.ice_ping(iceCurrent);
-            iceInS.setResult(iceInS.writeEmptyParams());
+            inS__.readEmptyParams();
+            __obj.ice_ping(__current);
+            inS__.setResult(inS__.writeEmptyParams());
             return null;
         }
 
@@ -147,17 +147,17 @@ namespace Ice
         /// <returns>An array whose only element is ::Ice::Object.</returns>
         public virtual string[] ice_ids(Current current = null)
         {
-            return s_iceIds;
+            return ids__;
         }
 
-        public static Task<Ice.OutputStream> iceD_ice_ids(Ice.Object iceObj, IceInternal.Incoming iceInS, Current iceCurrent)
+        public static Task<Ice.OutputStream> ice_ids___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
         {
-            iceInS.readEmptyParams();
-            var iceRet = iceObj.ice_ids(iceCurrent);
-            var iceOs = iceInS.startWriteParams();
-            iceOs.writeStringSeq(iceRet);
-            iceInS.endWriteParams(iceOs);
-            iceInS.setResult(iceOs);
+            inS__.readEmptyParams();
+            var ret__ = __obj.ice_ids(__current);
+            var os__ = inS__.startWriteParams();
+            os__.writeStringSeq(ret__);
+            inS__.endWriteParams(os__);
+            inS__.setResult(os__);
             return null;
         }
 
@@ -168,17 +168,17 @@ namespace Ice
         /// <returns>The return value is always ::Ice::Object.</returns>
         public virtual string ice_id(Current current = null)
         {
-            return s_iceIds[0];
+            return ids__[0];
         }
 
-        public static Task<Ice.OutputStream> iceD_ice_id(Ice.Object iceObj, IceInternal.Incoming iceInS, Current iceCurrent)
+        public static Task<Ice.OutputStream> ice_id___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
         {
-            iceInS.readEmptyParams();
-            var iceRet = iceObj.ice_id(iceCurrent);
-            var iceOs = iceInS.startWriteParams();
-            iceOs.writeString(iceRet);
-            iceInS.endWriteParams(iceOs);
-            iceInS.setResult(iceOs);
+            inS__.readEmptyParams();
+            var __ret = __obj.ice_id(__current);
+            var os__ = inS__.startWriteParams();
+            os__.writeString(__ret);
+            inS__.endWriteParams(os__);
+            inS__.setResult(os__);
             return null;
         }
 
@@ -188,10 +188,10 @@ namespace Ice
         /// <returns>The return value is always ::Ice::Object.</returns>
         public static string ice_staticId()
         {
-            return s_iceIds[0];
+            return ids__[0];
         }
 
-        private static readonly string[] s_iceAll = new string[]
+        private static readonly string[] all__ = new string[]
         {
             "ice_id", "ice_ids", "ice_isA", "ice_ping"
         };
@@ -206,12 +206,12 @@ namespace Ice
         {
             var inc = (IceInternal.Incoming)request;
             inc.startOver();
-            return iceDispatch(inc, inc.getCurrent());
+            return dispatch__(inc, inc.getCurrent());
         }
 
-        public virtual Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inc, Current current)
+        public virtual Task<Ice.OutputStream> dispatch__(IceInternal.Incoming inc, Current current)
         {
-            int pos = System.Array.BinarySearch(s_iceAll, current.operation);
+            int pos = System.Array.BinarySearch(all__, current.operation);
             if(pos < 0)
             {
                 throw new Ice.OperationNotExistException(current.id, current.facet, current.operation);
@@ -221,19 +221,19 @@ namespace Ice
             {
                 case 0:
                 {
-                    return iceD_ice_id(this, inc, current);
+                    return ice_id___(this, inc, current);
                 }
                 case 1:
                 {
-                    return iceD_ice_ids(this, inc, current);
+                    return ice_ids___(this, inc, current);
                 }
                 case 2:
                 {
-                    return iceD_ice_isA(this, inc, current);
+                    return ice_isA___(this, inc, current);
                 }
                 case 3:
                 {
-                    return iceD_ice_ping(this, inc, current);
+                    return ice_ping___(this, inc, current);
                 }
             }
 
@@ -260,7 +260,7 @@ namespace Ice
             return "???";
         }
 
-        public static void iceCheckMode(OperationMode expected, OperationMode received)
+        public static void checkMode__(OperationMode expected, OperationMode received)
         {
             if(expected != received)
             {
@@ -303,7 +303,7 @@ namespace Ice
         /// Ice run-time exception, it must throw it directly.</returns>
         public abstract bool ice_invoke(byte[] inParams, out byte[] outParams, Current current);
 
-        public override Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inS, Current current)
+        public override Task<Ice.OutputStream> dispatch__(IceInternal.Incoming inS, Current current)
         {
             byte[] inEncaps = inS.readParamEncaps();
             byte[] outEncaps;
@@ -317,7 +317,7 @@ namespace Ice
     {
         public abstract Task<Ice.Object_Ice_invokeResult> ice_invokeAsync(byte[] inEncaps, Current current);
 
-        public override Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inS, Current current)
+        public override Task<Ice.OutputStream> dispatch__(IceInternal.Incoming inS, Current current)
         {
             byte[] inEncaps = inS.readParamEncaps();
             return ice_invokeAsync(inEncaps, current).ContinueWith((Task<Ice.Object_Ice_invokeResult> t) =>
diff --git a/csharp/src/Ice/ObjectAdapterI.cs b/csharp/src/Ice/ObjectAdapterI.cs
index 5697b89151b..a1213d9ae99 100644
--- a/csharp/src/Ice/ObjectAdapterI.cs
+++ b/csharp/src/Ice/ObjectAdapterI.cs
@@ -450,7 +450,7 @@ namespace Ice
             {
                 checkForDeactivation();
 
-                Reference @ref = ((ObjectPrxHelperBase)proxy).iceReference();
+                Reference @ref = ((ObjectPrxHelperBase)proxy).reference__();
                 return findFacet(@ref.getIdentity(), @ref.getFacet());
             }
         }
@@ -617,7 +617,7 @@ namespace Ice
             // it can be called for AMI invocations if the proxy has no delegate set yet.
             //
 
-            Reference r = ((ObjectPrxHelperBase)proxy).iceReference();
+            Reference r = ((ObjectPrxHelperBase)proxy).reference__();
             if(r.isWellKnown())
             {
                 //
diff --git a/csharp/src/Ice/ObserverHelper.cs b/csharp/src/Ice/ObserverHelper.cs
index a6a15dded62..67e21f718a1 100644
--- a/csharp/src/Ice/ObserverHelper.cs
+++ b/csharp/src/Ice/ObserverHelper.cs
@@ -37,7 +37,7 @@ namespace IceInternal
         static public InvocationObserver get(Ice.ObjectPrx proxy, string op, Dictionary<string, string> context)
         {
             CommunicatorObserver obsv = 
-                ((Ice.ObjectPrxHelperBase)proxy).iceReference().getInstance().initializationData().observer;
+                ((Ice.ObjectPrxHelperBase)proxy).reference__().getInstance().initializationData().observer;
             if(obsv != null)
             {
                 InvocationObserver observer;
diff --git a/csharp/src/Ice/OutgoingAsync.cs b/csharp/src/Ice/OutgoingAsync.cs
index 0118e031db2..9fbc4fb71f4 100644
--- a/csharp/src/Ice/OutgoingAsync.cs
+++ b/csharp/src/Ice/OutgoingAsync.cs
@@ -423,7 +423,7 @@ namespace IceInternal
             }
 
             cachedConnection_ = null;
-            if(proxy_.iceReference().getInvocationTimeout() == -2)
+            if(proxy_.reference__().getInvocationTimeout() == -2)
             {
                 instance_.timer().cancel(this);
             }
@@ -439,7 +439,7 @@ namespace IceInternal
                 // the retry interval is 0. This method can be called with the
                 // connection locked so we can't just retry here.
                 //
-                instance_.retryQueue().add(this, proxy_.iceHandleException(exc, handler_, mode_, _sent, ref _cnt));
+                instance_.retryQueue().add(this, proxy_.handleException__(exc, handler_, mode_, _sent, ref _cnt));
                 return false;
             }
             catch(Ice.Exception ex)
@@ -450,7 +450,7 @@ namespace IceInternal
 
         public override void cancelable(CancellationHandler handler)
         {
-            if(proxy_.iceReference().getInvocationTimeout() == -2 && cachedConnection_ != null)
+            if(proxy_.reference__().getInvocationTimeout() == -2 && cachedConnection_ != null)
             {
                 int timeout = cachedConnection_.timeout();
                 if(timeout > 0)
@@ -471,7 +471,7 @@ namespace IceInternal
                 // require could end up waiting for the flush of the
                 // connection to be done.
                 //
-                proxy_.iceUpdateRequestHandler(handler_, null); // Clear request handler and always retry.
+                proxy_.updateRequestHandler__(handler_, null); // Clear request handler and always retry.
                 instance_.retryQueue().add(this, 0);
             }
             catch(Ice.Exception exc)
@@ -509,7 +509,7 @@ namespace IceInternal
                                          OutgoingAsyncCompletionCallback completionCallback,
                                          Ice.OutputStream os = null,
                                          Ice.InputStream iss = null) :
-            base(prx.iceReference().getInstance(), completionCallback, os, iss)
+            base(prx.reference__().getInstance(), completionCallback, os, iss)
         {
             proxy_ = prx;
             mode_ = Ice.OperationMode.Normal;
@@ -523,7 +523,7 @@ namespace IceInternal
             {
                 if(userThread)
                 {
-                    int invocationTimeout = proxy_.iceReference().getInvocationTimeout();
+                    int invocationTimeout = proxy_.reference__().getInvocationTimeout();
                     if(invocationTimeout > 0)
                     {
                         instance_.timer().schedule(this, invocationTimeout);
@@ -539,7 +539,7 @@ namespace IceInternal
                     try
                     {
                         _sent = false;
-                        handler_ = proxy_.iceGetRequestHandler();
+                        handler_ = proxy_.getRequestHandler__();
                         int status = handler_.sendAsyncRequest(this);
                         if((status & AsyncStatusSent) != 0)
                         {
@@ -563,7 +563,7 @@ namespace IceInternal
                     }
                     catch(RetryException)
                     {
-                        proxy_.iceUpdateRequestHandler(handler_, null); // Clear request handler and always retry.
+                        proxy_.updateRequestHandler__(handler_, null); // Clear request handler and always retry.
                     }
                     catch(Ice.Exception ex)
                     {
@@ -573,7 +573,7 @@ namespace IceInternal
                             childObserver_.detach();
                             childObserver_ = null;
                         }
-                        int interval = proxy_.iceHandleException(ex, handler_, mode_, _sent, ref _cnt);
+                        int interval = proxy_.handleException__(ex, handler_, mode_, _sent, ref _cnt);
                         if(interval > 0)
                         {
                             instance_.retryQueue().add(this, interval);
@@ -607,7 +607,7 @@ namespace IceInternal
             _sent = true;
             if(done)
             {
-                if(proxy_.iceReference().getInvocationTimeout() != -1)
+                if(proxy_.reference__().getInvocationTimeout() != -1)
                 {
                     instance_.timer().cancel(this);
                 }
@@ -616,7 +616,7 @@ namespace IceInternal
         }
         protected override bool exceptionImpl(Ice.Exception ex)
         {
-            if(proxy_.iceReference().getInvocationTimeout() != -1)
+            if(proxy_.reference__().getInvocationTimeout() != -1)
             {
                 instance_.timer().cancel(this);
             }
@@ -625,7 +625,7 @@ namespace IceInternal
 
         protected override bool responseImpl(bool ok)
         {
-            if(proxy_.iceReference().getInvocationTimeout() != -1)
+            if(proxy_.reference__().getInvocationTimeout() != -1)
             {
                 instance_.timer().cancel(this);
             }
@@ -634,7 +634,7 @@ namespace IceInternal
 
         public void runTimerTask()
         {
-            if(proxy_.iceReference().getInvocationTimeout() == -2)
+            if(proxy_.reference__().getInvocationTimeout() == -2)
             {
                 cancel(new Ice.ConnectionTimeoutException());
             }
@@ -661,21 +661,21 @@ namespace IceInternal
                              Ice.OutputStream os = null, Ice.InputStream iss = null) :
             base(prx, completionCallback, os, iss)
         {
-            encoding_ = Protocol.getCompatibleEncoding(proxy_.iceReference().getEncoding());
+            encoding_ = Protocol.getCompatibleEncoding(proxy_.reference__().getEncoding());
             synchronous_ = false;
         }
 
         public void prepare(string operation, Ice.OperationMode mode, Dictionary<string, string> context,
                             bool synchronous)
         {
-            Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.iceReference().getProtocol()));
+            Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol()));
 
             mode_ = mode;
             synchronous_ = synchronous;
 
             observer_ = ObserverHelper.get(proxy_, operation, context);
 
-            switch(proxy_.iceReference().getMode())
+            switch(proxy_.reference__().getMode())
             {
                 case Reference.Mode.ModeTwoway:
                 case Reference.Mode.ModeOneway:
@@ -688,14 +688,14 @@ namespace IceInternal
                 case Reference.Mode.ModeBatchOneway:
                 case Reference.Mode.ModeBatchDatagram:
                 {
-                    proxy_.iceGetBatchRequestQueue().prepareBatchRequest(os_);
+                    proxy_.getBatchRequestQueue__().prepareBatchRequest(os_);
                     break;
                 }
             }
 
-            Reference rf = proxy_.iceReference();
+            Reference rf = proxy_.reference__();
 
-            rf.getIdentity().iceWrite(os_);
+            rf.getIdentity().write__(os_);
 
             //
             // For compatibility with the old FacetPath.
@@ -786,7 +786,7 @@ namespace IceInternal
                     case ReplyStatus.replyOperationNotExist:
                     {
                         Ice.Identity ident = new Ice.Identity();
-                        ident.iceRead(is_);
+                        ident.read__(is_);
 
                         //
                         // For compatibility with the old FacetPath.
@@ -904,7 +904,7 @@ namespace IceInternal
         public override int invokeCollocated(CollocatedRequestHandler handler)
         {
             // The stream cannot be cached if the proxy is not a twoway or there is an invocation timeout set.
-            if(!proxy_.ice_isTwoway() || proxy_.iceReference().getInvocationTimeout() != -1)
+            if(!proxy_.ice_isTwoway() || proxy_.reference__().getInvocationTimeout() != -1)
             {
                 // Disable caching by marking the streams as cached!
                 state_ |= StateCachedBuffers;
@@ -914,7 +914,7 @@ namespace IceInternal
 
         public new void abort(Ice.Exception ex)
         {
-            Reference.Mode mode = proxy_.iceReference().getMode();
+            Reference.Mode mode = proxy_.reference__().getMode();
             if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram)
             {
                 //
@@ -922,7 +922,7 @@ namespace IceInternal
                 // must notify the connection about that we give up ownership
                 // of the batch stream.
                 //
-                proxy_.iceGetBatchRequestQueue().abortBatchRequest(os_);
+                proxy_.getBatchRequestQueue__().abortBatchRequest(os_);
             }
 
             base.abort(ex);
@@ -930,11 +930,11 @@ namespace IceInternal
 
         public void invoke(string operation)
         {
-            Reference.Mode mode = proxy_.iceReference().getMode();
+            Reference.Mode mode = proxy_.reference__().getMode();
             if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram)
             {
                 sentSynchronously_ = true;
-                proxy_.iceGetBatchRequestQueue().finishBatchRequest(os_, proxy_, operation);
+                proxy_.getBatchRequestQueue__().finishBatchRequest(os_, proxy_, operation);
                 responseImpl(true);
                 return; // Don't call sent/completed callback for batch AMI requests
             }
@@ -995,7 +995,7 @@ namespace IceInternal
 
         public override void cacheMessageBuffers()
         {
-            if(proxy_.iceReference().getInstance().cacheMessageBuffers() > 0)
+            if(proxy_.reference__().getInstance().cacheMessageBuffers() > 0)
             {
                 lock(this)
                 {
@@ -1048,7 +1048,7 @@ namespace IceInternal
             base.invoke(operation, mode, format, context, synchronous, write);
         }
 
-        public T iceResult(bool ok)
+        public T result__(bool ok)
         {
             try
             {
@@ -1138,9 +1138,9 @@ namespace IceInternal
 
         public void invoke(string operation)
         {
-            Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.iceReference().getProtocol()));
+            Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol()));
             observer_ = ObserverHelper.get(proxy_, operation, null);
-            _batchRequestNum = proxy_.iceGetBatchRequestQueue().swap(os_);
+            _batchRequestNum = proxy_.getBatchRequestQueue__().swap(os_);
             invokeImpl(true); // userThread = true
         }
 
@@ -1440,7 +1440,7 @@ namespace IceInternal
 
         public override bool handleResponse(bool ok, OutgoingAsyncBase og)
         {
-            SetResult(((OutgoingAsyncT<T>)og).iceResult(ok));
+            SetResult(((OutgoingAsyncT<T>)og).result__(ok));
             return false;
         }
     }
@@ -1561,7 +1561,7 @@ namespace IceInternal
     {
         public ProxyAsyncResultCompletionCallback(Ice.ObjectPrxHelperBase proxy, string operation, object cookie,
                                                   Ice.AsyncCallback cb) :
-            base(proxy.ice_getCommunicator(), proxy.iceReference().getInstance(), operation, cookie, cb)
+            base(proxy.ice_getCommunicator(), proxy.reference__().getInstance(), operation, cookie, cb)
         {
             _proxy = proxy;
         }
@@ -1625,7 +1625,7 @@ namespace IceInternal
                 Debug.Assert(r == this);
                 try
                 {
-                    R result = ((OutgoingAsyncT<R>)outgoing_).iceResult(wait());
+                    R result = ((OutgoingAsyncT<R>)outgoing_).result__(wait());
                     try
                     {
                         _completed(responseCallback_, result);
diff --git a/csharp/src/Ice/OutputStream.cs b/csharp/src/Ice/OutputStream.cs
index 3b2e1e0aa60..89f42e694f3 100644
--- a/csharp/src/Ice/OutputStream.cs
+++ b/csharp/src/Ice/OutputStream.cs
@@ -343,7 +343,7 @@ namespace Ice
             _encapsStack.start = _buf.b.position();
 
             writeInt(0); // Placeholder for the encapsulation length.
-            _encapsStack.encoding.iceWrite(this);
+            _encapsStack.encoding.write__(this);
         }
 
         /// <summary>
@@ -373,7 +373,7 @@ namespace Ice
         {
             Protocol.checkSupportedEncoding(encoding);
             writeInt(6); // Size
-            encoding.iceWrite(this);
+            encoding.write__(this);
         }
 
         /// <summary>
@@ -1967,12 +1967,12 @@ namespace Ice
         {
             if(v != null)
             {
-                v.iceWrite(this);
+                v.write__(this);
             }
             else
             {
                 Identity ident = new Identity();
-                ident.iceWrite(this);
+                ident.write__(this);
             }
         }
 
@@ -2258,9 +2258,9 @@ namespace Ice
                 // This allows reading the pending instances even if some part of
                 // the exception was sliced.
                 //
-                bool usesClasses = v.iceUsesClasses();
+                bool usesClasses = v.usesClasses__();
                 _stream.writeBool(usesClasses);
-                v.iceWrite(_stream);
+                v.write__(_stream);
                 if(usesClasses)
                 {
                     writePendingValues();
@@ -2363,7 +2363,7 @@ namespace Ice
                             _stream.instance().initializationData().logger.warning(s);
                         }
 
-                        p.Key.iceWrite(_stream);
+                        p.Key.write__(_stream);
                     }
                 }
                 _stream.writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
@@ -2456,7 +2456,7 @@ namespace Ice
 
             internal override void writeException(UserException v)
             {
-                v.iceWrite(_stream);
+                v.write__(_stream);
             }
 
             internal override void startInstance(SliceType sliceType, SlicedData data)
@@ -2700,7 +2700,7 @@ namespace Ice
                 }
 
                 _stream.writeSize(1); // Object instance marker.
-                v.iceWrite(_stream);
+                v.write__(_stream);
             }
 
             private sealed class InstanceData
@@ -2820,12 +2820,12 @@ namespace Ice
         /// <param name="outStream">The stream to write to.</param>
         public abstract void write(OutputStream outStream);
 
-        public override void iceWrite(OutputStream os)
+        public override void write__(OutputStream os)
         {
             write(os);
         }
 
-        public override void iceRead(InputStream istr)
+        public override void read__(InputStream istr)
         {
             Debug.Assert(false);
         }
diff --git a/csharp/src/Ice/Proxy.cs b/csharp/src/Ice/Proxy.cs
index 1686687a743..a155f908c72 100644
--- a/csharp/src/Ice/Proxy.cs
+++ b/csharp/src/Ice/Proxy.cs
@@ -21,21 +21,21 @@ namespace Ice
 {
     /// <summary>
     /// Delegate for a successful <code>ice_isA</code> invocation.
-    /// <param name="iceRet">True if the remote object supports the type, false otherwise.</param>
+    /// <param name="ret__">True if the remote object supports the type, false otherwise.</param>
     /// </summary>
-    public delegate void Callback_Object_ice_isA(bool iceRet);
+    public delegate void Callback_Object_ice_isA(bool ret__);
 
     /// <summary>
     /// Delegate for a successful <code>ice_ids</code> invocation.
-    /// <param name="iceRet">The array of Slice type ids supported by the remote object.</param>
+    /// <param name="ret__">The array of Slice type ids supported by the remote object.</param>
     /// </summary>
-    public delegate void Callback_Object_ice_ids(string[] iceRet);
+    public delegate void Callback_Object_ice_ids(string[] ret__);
 
     /// <summary>
     /// Delegate for a successful <code>ice_id</code> invocation.
-    /// <param name="iceRet">The Slice type id of the most-derived interface supported by the remote object.</param>
+    /// <param name="ret__">The Slice type id of the most-derived interface supported by the remote object.</param>
     /// </summary>
-    public delegate void Callback_Object_ice_id(string iceRet);
+    public delegate void Callback_Object_ice_id(string ret__);
 
     /// <summary>
     /// Delegate for a successful <code>ice_ping</code> invocation.
@@ -44,17 +44,17 @@ namespace Ice
 
     /// <summary>
     /// Delegate for a successful <code>ice_invoke</code> invocation.
-    /// <param name="iceRet">True if the invocation succeeded, or false if the invocation
+    /// <param name="ret__">True if the invocation succeeded, or false if the invocation
     /// raised a user exception.</param>
     /// <param name="outEncaps">The encoded out-parameters or user exception.</param>
     /// </summary>
-    public delegate void Callback_Object_ice_invoke(bool iceRet, byte[] outEncaps);
+    public delegate void Callback_Object_ice_invoke(bool ret__, byte[] outEncaps);
 
     /// <summary>
     /// Delegate for a successful <code>ice_getConnection</code> invocation.
-    /// <param name="iceRet">The connection used by the proxy.</param>
+    /// <param name="ret__">The connection used by the proxy.</param>
     /// </summary>
-    public delegate void Callback_Object_ice_getConnection(Connection iceRet);
+    public delegate void Callback_Object_ice_getConnection(Connection ret__);
 
     /// <summary>
     /// Value type to allow differenciate between a context that is explicity set to
@@ -767,7 +767,7 @@ namespace Ice
         /// Write a proxy to the output stream.
         /// </summary>
         /// <param name="os">Output stream object to write the proxy.</param>
-        void iceWrite(OutputStream os);
+        void write__(OutputStream os);
     }
 
     /// <summary>
@@ -901,7 +901,7 @@ namespace Ice
                      bool synchronous)
         {
             var completed = new OperationTaskCompletionCallback<bool>(progress, cancel);
-            iceI_ice_isA(id, context, completed, synchronous);
+            ice_isA_invoke__(id, context, completed, synchronous);
             return completed.Task;
         }
 
@@ -942,7 +942,7 @@ namespace Ice
             return begin_ice_isA(id, context, null, null, false);
         }
 
-        internal const string _ice_isA_name = "ice_isA";
+        internal const string __ice_isA_name = "ice_isA";
 
         /// <summary>
         /// Tests whether this object supports a specific Slice interface.
@@ -951,8 +951,8 @@ namespace Ice
         /// <returns>True if the object supports the Slice interface, false otherwise.</returns>
         public bool end_ice_isA(AsyncResult result)
         {
-            var resultI = AsyncResultI.check(result, this, _ice_isA_name);
-            return ((OutgoingAsyncT<bool>)resultI.OutgoingAsync).iceResult(resultI.wait());
+            var resultI = AsyncResultI.check(result, this, __ice_isA_name);
+            return ((OutgoingAsyncT<bool>)resultI.OutgoingAsync).result__(resultI.wait());
         }
 
         private AsyncResult<Callback_Object_ice_isA>
@@ -966,18 +966,18 @@ namespace Ice
                     {
                         cb.Invoke(result);
                     }
-                }, this, _ice_isA_name, cookie, callback);
-            iceI_ice_isA(id, context, completed, synchronous);
+                }, this, __ice_isA_name, cookie, callback);
+            ice_isA_invoke__(id, context, completed, synchronous);
             return completed;
         }
 
-        private void iceI_ice_isA(string id,
+        private void ice_isA_invoke__(string id,
                                       Dictionary<string, string> context,
                                       OutgoingAsyncCompletionCallback completed,
                                       bool synchronous)
         {
-            iceCheckAsyncTwowayOnly(_ice_isA_name);
-            getOutgoingAsync<bool>(completed).invoke(_ice_isA_name,
+            checkAsyncTwowayOnly__(__ice_isA_name);
+            getOutgoingAsync<bool>(completed).invoke(__ice_isA_name,
                                                      OperationMode.Nonmutating,
                                                      FormatType.DefaultFormat,
                                                      context,
@@ -1021,7 +1021,7 @@ namespace Ice
         ice_pingAsync(OptionalContext context, IProgress<bool> progress, CancellationToken cancel, bool synchronous)
         {
             var completed = new OperationTaskCompletionCallback<object>(progress, cancel);
-            iceI_ice_ping(context, completed, synchronous);
+            ice_ping_invoke__(context, completed, synchronous);
             return completed.Task;
         }
 
@@ -1059,7 +1059,7 @@ namespace Ice
             return begin_ice_ping(context, null, null, false);
         }
 
-        internal const string _ice_ping_name = "ice_ping";
+        internal const string __ice_ping_name = "ice_ping";
 
         /// <summary>
         /// Tests whether the target object of this proxy can be reached.
@@ -1067,8 +1067,8 @@ namespace Ice
         /// <param name="result">The asynchronous result object returned by <code>begin_ice_ping</code>.</param>
         public void end_ice_ping(AsyncResult result)
         {
-            var resultI = AsyncResultI.check(result, this, _ice_ping_name);
-            ((OutgoingAsyncT<object>)resultI.OutgoingAsync).iceResult(resultI.wait());
+            var resultI = AsyncResultI.check(result, this, __ice_ping_name);
+            ((OutgoingAsyncT<object>)resultI.OutgoingAsync).result__(resultI.wait());
         }
 
         private AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context,
@@ -1083,15 +1083,15 @@ namespace Ice
                     {
                         cb.Invoke();
                     }
-                }, this, _ice_ping_name, cookie, callback);
-            iceI_ice_ping(context, completed, synchronous);
+                }, this, __ice_ping_name, cookie, callback);
+            ice_ping_invoke__(context, completed, synchronous);
             return completed;
         }
 
-        private void iceI_ice_ping(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed,
+        private void ice_ping_invoke__(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed,
                                        bool synchronous)
         {
-            getOutgoingAsync<object>(completed).invoke(_ice_ping_name,
+            getOutgoingAsync<object>(completed).invoke(__ice_ping_name,
                                                        OperationMode.Nonmutating,
                                                        FormatType.DefaultFormat,
                                                        context,
@@ -1135,7 +1135,7 @@ namespace Ice
                                             bool synchronous)
         {
             var completed = new OperationTaskCompletionCallback<string[]>(progress, cancel);
-            iceI_ice_ids(context, completed, false);
+            ice_ids_invoke__(context, completed, false);
             return completed.Task;
         }
 
@@ -1169,7 +1169,7 @@ namespace Ice
             return begin_ice_ids(context, null, null, false);
         }
 
-        internal const string _ice_ids_name = "ice_ids";
+        internal const string __ice_ids_name = "ice_ids";
 
         private AsyncResult<Callback_Object_ice_ids>
         begin_ice_ids(Dictionary<string, string> context, AsyncCallback callback, object cookie, bool synchronous)
@@ -1181,8 +1181,8 @@ namespace Ice
                     {
                         cb.Invoke(result);
                     }
-                }, this, _ice_ids_name, cookie, callback);
-            iceI_ice_ids(context, completed, synchronous);
+                }, this, __ice_ids_name, cookie, callback);
+            ice_ids_invoke__(context, completed, synchronous);
             return completed;
         }
 
@@ -1194,15 +1194,15 @@ namespace Ice
         /// order. The first element of the returned array is always ::Ice::Object.</returns>
         public string[] end_ice_ids(AsyncResult result)
         {
-            var resultI = AsyncResultI.check(result, this, _ice_ids_name);
-            return ((OutgoingAsyncT<string[]>)resultI.OutgoingAsync).iceResult(resultI.wait());
+            var resultI = AsyncResultI.check(result, this, __ice_ids_name);
+            return ((OutgoingAsyncT<string[]>)resultI.OutgoingAsync).result__(resultI.wait());
         }
 
-        private void iceI_ice_ids(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed,
+        private void ice_ids_invoke__(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed,
                                       bool synchronous)
         {
-            iceCheckAsyncTwowayOnly(_ice_ids_name);
-            getOutgoingAsync<string[]>(completed).invoke(_ice_ids_name,
+            checkAsyncTwowayOnly__(__ice_ids_name);
+            getOutgoingAsync<string[]>(completed).invoke(__ice_ids_name,
                                                          OperationMode.Nonmutating,
                                                          FormatType.DefaultFormat,
                                                          context,
@@ -1244,7 +1244,7 @@ namespace Ice
         ice_idAsync(OptionalContext context, IProgress<bool> progress, CancellationToken cancel, bool synchronous)
         {
             var completed = new OperationTaskCompletionCallback<string>(progress, cancel);
-            iceI_ice_id(context, completed, synchronous);
+            ice_id_invoke__(context, completed, synchronous);
             return completed.Task;
         }
 
@@ -1283,7 +1283,7 @@ namespace Ice
             return begin_ice_id(context, null, null, false);
         }
 
-        internal const string _ice_id_name = "ice_id";
+        internal const string __ice_id_name = "ice_id";
 
         private AsyncResult<Callback_Object_ice_id>
         begin_ice_id(Dictionary<string, string> context, AsyncCallback callback, object cookie, bool synchronous)
@@ -1295,8 +1295,8 @@ namespace Ice
                     {
                         cb.Invoke(result);
                     }
-                }, this, _ice_id_name, cookie, callback);
-            iceI_ice_id(context, completed, synchronous);
+                }, this, __ice_id_name, cookie, callback);
+            ice_id_invoke__(context, completed, synchronous);
             return completed;
         }
 
@@ -1307,16 +1307,16 @@ namespace Ice
         /// <returns>The Slice type ID of the most-derived interface.</returns>
         public string end_ice_id(AsyncResult result)
         {
-            var resultI = AsyncResultI.check(result, this, _ice_id_name);
-            return ((OutgoingAsyncT<string>)resultI.OutgoingAsync).iceResult(resultI.wait());
+            var resultI = AsyncResultI.check(result, this, __ice_id_name);
+            return ((OutgoingAsyncT<string>)resultI.OutgoingAsync).result__(resultI.wait());
         }
 
-        private void iceI_ice_id(Dictionary<string, string> context,
+        private void ice_id_invoke__(Dictionary<string, string> context,
                                      OutgoingAsyncCompletionCallback completed,
                                      bool synchronous)
         {
-            iceCheckAsyncTwowayOnly(_ice_id_name);
-            getOutgoingAsync<string>(completed).invoke(_ice_id_name,
+            checkAsyncTwowayOnly__(__ice_id_name);
+            getOutgoingAsync<string>(completed).invoke(__ice_id_name,
                                                        OperationMode.Nonmutating,
                                                        FormatType.DefaultFormat,
                                                        context,
@@ -1387,7 +1387,7 @@ namespace Ice
                         bool synchronous)
         {
             var completed = new InvokeTaskCompletionCallback(progress, cancel);
-            iceI_ice_invoke(operation, mode, inEncaps, context, completed, synchronous);
+            ice_invoke_invoke__(operation, mode, inEncaps, context, completed, synchronous);
             return completed.Task;
         }
 
@@ -1448,7 +1448,7 @@ namespace Ice
             return begin_ice_invoke(operation, mode, inEncaps, context, null, null, false);
         }
 
-        internal const string _ice_invoke_name = "ice_invoke";
+        internal const string __ice_invoke_name = "ice_invoke";
 
         /// <summary>
         /// Completes a dynamic invocation.
@@ -1462,8 +1462,8 @@ namespace Ice
         /// it throws it directly.</returns>
         public bool end_ice_invoke(out byte[] outEncaps, AsyncResult result)
         {
-            var resultI = AsyncResultI.check(result, this, _ice_invoke_name);
-            var r = ((InvokeOutgoingAsyncT)resultI.OutgoingAsync).iceResult(resultI.wait());
+            var resultI = AsyncResultI.check(result, this, __ice_invoke_name);
+            var r = ((InvokeOutgoingAsyncT)resultI.OutgoingAsync).result__(resultI.wait());
             outEncaps = r.outEncaps;
             return r.returnValue;
         }
@@ -1477,12 +1477,12 @@ namespace Ice
                          object cookie,
                          bool synchronous)
         {
-            var completed = new InvokeAsyncResultCompletionCallback(this, _ice_invoke_name, cookie, callback);
-            iceI_ice_invoke(operation, mode, inEncaps, context, completed, synchronous);
+            var completed = new InvokeAsyncResultCompletionCallback(this, __ice_invoke_name, cookie, callback);
+            ice_invoke_invoke__(operation, mode, inEncaps, context, completed, synchronous);
             return completed;
         }
 
-        private void iceI_ice_invoke(string operation,
+        private void ice_invoke_invoke__(string operation,
                                          OperationMode mode,
                                          byte[] inEncaps,
                                          Dictionary<string, string> context,
@@ -2186,7 +2186,7 @@ namespace Ice
             var outgoing = new ProxyGetConnection(this, completed);
             try
             {
-                outgoing.invoke(_ice_getConnection_name);
+                outgoing.invoke(__ice_getConnection_name);
             }
             catch(Exception ex)
             {
@@ -2200,7 +2200,7 @@ namespace Ice
             return begin_ice_getConnectionInternal(null, null);
         }
 
-        internal const string _ice_getConnection_name = "ice_getConnection";
+        internal const string __ice_getConnection_name = "ice_getConnection";
 
         public AsyncResult begin_ice_getConnection(AsyncCallback cb, object cookie)
         {
@@ -2209,7 +2209,7 @@ namespace Ice
 
         public Connection end_ice_getConnection(AsyncResult r)
         {
-            var resultI = AsyncResultI.check(r, this, _ice_getConnection_name);
+            var resultI = AsyncResultI.check(r, this, __ice_getConnection_name);
             resultI.wait();
             return ((ProxyGetConnection)resultI.OutgoingAsync).getConnection();
         }
@@ -2217,11 +2217,11 @@ namespace Ice
         private AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnectionInternal(AsyncCallback callback,
                                                                                                object cookie)
         {
-            var completed = new ProxyGetConnectionAsyncCallback(this, _ice_getConnection_name, cookie, callback);
+            var completed = new ProxyGetConnectionAsyncCallback(this, __ice_getConnection_name, cookie, callback);
             var outgoing = new ProxyGetConnection(this, completed);
             try
             {
-                outgoing.invoke(_ice_getConnection_name);
+                outgoing.invoke(__ice_getConnection_name);
             }
             catch(Exception ex)
             {
@@ -2274,7 +2274,7 @@ namespace Ice
             }
         }
 
-        internal const string _ice_flushBatchRequests_name = "ice_flushBatchRequests";
+        internal const string __ice_flushBatchRequests_name = "ice_flushBatchRequests";
 
         public Task ice_flushBatchRequestsAsync(IProgress<bool> progress = null,
                                                 CancellationToken cancel = new CancellationToken())
@@ -2283,7 +2283,7 @@ namespace Ice
             var outgoing = new ProxyFlushBatchAsync(this, completed);
             try
             {
-                outgoing.invoke(_ice_flushBatchRequests_name);
+                outgoing.invoke(__ice_flushBatchRequests_name);
             }
             catch(Exception ex)
             {
@@ -2298,7 +2298,7 @@ namespace Ice
                                                         string operation,
                                                         object cookie,
                                                         AsyncCallback callback) :
-                base(proxy.ice_getCommunicator(), ((ObjectPrxHelperBase)proxy).iceReference().getInstance(),
+                base(proxy.ice_getCommunicator(), ((ObjectPrxHelperBase)proxy).reference__().getInstance(),
                      operation, cookie, callback)
             {
                 _proxy = proxy;
@@ -2332,11 +2332,11 @@ namespace Ice
 
         public AsyncResult begin_ice_flushBatchRequests(AsyncCallback cb = null, object cookie = null)
         {
-            var completed = new ProxyFlushBatchRequestsAsyncCallback(this, _ice_flushBatchRequests_name, cookie, cb);
+            var completed = new ProxyFlushBatchRequestsAsyncCallback(this, __ice_flushBatchRequests_name, cookie, cb);
             var outgoing = new ProxyFlushBatchAsync(this, completed);
             try
             {
-                outgoing.invoke(_ice_flushBatchRequests_name);
+                outgoing.invoke(__ice_flushBatchRequests_name);
             }
             catch(Exception ex)
             {
@@ -2347,7 +2347,7 @@ namespace Ice
 
         public void end_ice_flushBatchRequests(AsyncResult r)
         {
-            var resultI = AsyncResultI.check(r, this, _ice_flushBatchRequests_name);
+            var resultI = AsyncResultI.check(r, this, __ice_flushBatchRequests_name);
             resultI.wait();
         }
 
@@ -2399,18 +2399,18 @@ namespace Ice
             return !Equals(lhs, rhs);
         }
 
-        public void iceWrite(OutputStream os)
+        public void write__(OutputStream os)
         {
-            _reference.getIdentity().iceWrite(os);
+            _reference.getIdentity().write__(os);
             _reference.streamWrite(os);
         }
 
-        public Reference iceReference()
+        public Reference reference__()
         {
             return _reference;
         }
 
-        public void iceCopyFrom(ObjectPrx from)
+        public void copyFrom__(ObjectPrx from)
         {
             lock(from)
             {
@@ -2420,10 +2420,10 @@ namespace Ice
             }
         }
 
-        public int iceHandleException(Exception ex, RequestHandler handler, OperationMode mode, bool sent,
+        public int handleException__(Exception ex, RequestHandler handler, OperationMode mode, bool sent,
                                      ref int cnt)
         {
-            iceUpdateRequestHandler(handler, null); // Clear the request handler
+            updateRequestHandler__(handler, null); // Clear the request handler
 
             //
             // We only retry local exception, system exceptions aren't retried.
@@ -2465,7 +2465,7 @@ namespace Ice
             }
         }
 
-        public void iceCheckAsyncTwowayOnly(string name)
+        public void checkAsyncTwowayOnly__(string name)
         {
             //
             // No mutex lock necessary, there is nothing mutable in this
@@ -2478,7 +2478,7 @@ namespace Ice
             }
         }
 
-        public RequestHandler iceGetRequestHandler()
+        public RequestHandler getRequestHandler__()
         {
             if(_reference.getCacheConnection())
             {
@@ -2494,7 +2494,7 @@ namespace Ice
         }
 
         public BatchRequestQueue
-        iceGetBatchRequestQueue()
+        getBatchRequestQueue__()
         {
             lock(this)
             {
@@ -2507,7 +2507,7 @@ namespace Ice
         }
 
         public RequestHandler
-        iceSetRequestHandler(RequestHandler handler)
+        setRequestHandler__(RequestHandler handler)
         {
             if(_reference.getCacheConnection())
             {
@@ -2523,7 +2523,7 @@ namespace Ice
             return handler;
         }
 
-        public void iceUpdateRequestHandler(RequestHandler previous, RequestHandler handler)
+        public void updateRequestHandler__(RequestHandler previous, RequestHandler handler)
         {
             if(_reference.getCacheConnection() && previous != null)
             {
@@ -2607,22 +2607,22 @@ namespace Ice
             }
 
             public Object_Ice_invokeResult
-            iceResult(bool ok)
+            result__(bool ok)
             {
                 try
                 {
-                    var iceRet = new Object_Ice_invokeResult();
+                    var ret__ = new Object_Ice_invokeResult();
                     EncodingVersion encoding;
-                    if(proxy_.iceReference().getMode() == Reference.Mode.ModeTwoway)
+                    if(proxy_.reference__().getMode() == Reference.Mode.ModeTwoway)
                     {
-                        iceRet.outEncaps = is_.readEncapsulation(out encoding);
+                        ret__.outEncaps = is_.readEncapsulation(out encoding);
                     }
                     else
                     {
-                        iceRet.outEncaps = null;
+                        ret__.outEncaps = null;
                     }
-                    iceRet.returnValue = ok;
-                    return iceRet;
+                    ret__.returnValue = ok;
+                    return ret__;
                 }
                 finally
                 {
@@ -2648,7 +2648,7 @@ namespace Ice
                     Debug.Assert(r == this);
                     try
                     {
-                        Object_Ice_invokeResult result = ((InvokeOutgoingAsyncT)outgoing_).iceResult(wait());
+                        Object_Ice_invokeResult result = ((InvokeOutgoingAsyncT)outgoing_).result__(wait());
                         try
                         {
                             if(responseCallback_ != null)
@@ -2692,7 +2692,7 @@ namespace Ice
 
             public override bool handleResponse(bool ok, OutgoingAsyncBase og)
             {
-                SetResult(((InvokeOutgoingAsyncT)og).iceResult(ok));
+                SetResult(((InvokeOutgoingAsyncT)og).result__(ok));
                 return false;
             }
         }
@@ -2829,7 +2829,7 @@ namespace Ice
                     var ok = bb.ice_isA("::Ice::Object");
                     Debug.Assert(ok);
                     ObjectPrxHelper h = new ObjectPrxHelper();
-                    h.iceCopyFrom(bb);
+                    h.copyFrom__(bb);
                     d = h;
                 }
                 catch(FacetNotExistException)
@@ -2860,7 +2860,7 @@ namespace Ice
                     var ok = bb.ice_isA("::Ice::Object", ctx);
                     Debug.Assert(ok);
                     ObjectPrxHelper h = new ObjectPrxHelper();
-                    h.iceCopyFrom(bb);
+                    h.copyFrom__(bb);
                     d = h;
                 }
                 catch(FacetNotExistException)
@@ -2895,7 +2895,7 @@ namespace Ice
             {
                 var bb = b.ice_facet(f);
                 var h = new ObjectPrxHelper();
-                h.iceCopyFrom(bb);
+                h.copyFrom__(bb);
                 d = h;
             }
             return d;
diff --git a/csharp/src/Ice/ProxyFactory.cs b/csharp/src/Ice/ProxyFactory.cs
index 017b7ddd011..11a204f7a10 100644
--- a/csharp/src/Ice/ProxyFactory.cs
+++ b/csharp/src/Ice/ProxyFactory.cs
@@ -26,7 +26,7 @@ namespace IceInternal
             if(proxy != null)
             {
                 Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase) proxy;
-                return h.iceReference().ToString();
+                return h.reference__().ToString();
             }
             else
             {
@@ -46,7 +46,7 @@ namespace IceInternal
             if(proxy != null)
             {
                 Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase) proxy;
-                return h.iceReference().toProperty(prefix);
+                return h.reference__().toProperty(prefix);
             }
             else
             {
@@ -57,7 +57,7 @@ namespace IceInternal
         public Ice.ObjectPrx streamToProxy(Ice.InputStream s)
         {
             Ice.Identity ident = new Ice.Identity();
-            ident.iceRead(s);
+            ident.read__(s);
 
             Reference r = instance_.referenceFactory().create(ident, s);
             return referenceToProxy(r);
diff --git a/csharp/src/Ice/Reference.cs b/csharp/src/Ice/Reference.cs
index de303f30e28..19493d35d0a 100644
--- a/csharp/src/Ice/Reference.cs
+++ b/csharp/src/Ice/Reference.cs
@@ -269,8 +269,8 @@ namespace IceInternal
 
             if(!s.getEncoding().Equals(Ice.Util.Encoding_1_0))
             {
-                protocol_.iceWrite(s);
-                encoding_.iceWrite(s);
+                protocol_.write__(s);
+                encoding_.write__(s);
             }
 
             // Derived class writes the remainder of the reference.
@@ -728,7 +728,7 @@ namespace IceInternal
                 compress = _fixedConnection.endpoint().compress();
             }
 
-            return ((Ice.ObjectPrxHelperBase)proxy).iceSetRequestHandler(new ConnectionRequestHandler(this,
+            return ((Ice.ObjectPrxHelperBase)proxy).setRequestHandler__(new ConnectionRequestHandler(this,
                                                                                                      _fixedConnection,
                                                                                                      compress));
         }
@@ -1090,7 +1090,7 @@ namespace IceInternal
             if(_routerInfo != null)
             {
                 Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase)_routerInfo.getRouter();
-                Dictionary<String, String> routerProperties = h.iceReference().toProperty(prefix + ".Router");
+                Dictionary<String, String> routerProperties = h.reference__().toProperty(prefix + ".Router");
                 foreach(KeyValuePair<string, string> entry in routerProperties)
                 {
                     properties[entry.Key] = entry.Value;
@@ -1100,7 +1100,7 @@ namespace IceInternal
             if(_locatorInfo != null)
             {
                 Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase)_locatorInfo.getLocator();
-                Dictionary<String, String> locatorProperties = h.iceReference().toProperty(prefix + ".Locator");
+                Dictionary<String, String> locatorProperties = h.reference__().toProperty(prefix + ".Locator");
                 foreach(KeyValuePair<string, string> entry in locatorProperties)
                 {
                     properties[entry.Key] = entry.Value;
diff --git a/csharp/src/Ice/ReferenceFactory.cs b/csharp/src/Ice/ReferenceFactory.cs
index a837ada3853..eaca68feead 100644
--- a/csharp/src/Ice/ReferenceFactory.cs
+++ b/csharp/src/Ice/ReferenceFactory.cs
@@ -593,9 +593,9 @@ namespace IceInternal
             if(!s.getEncoding().Equals(Ice.Util.Encoding_1_0))
             {
                 protocol = new Ice.ProtocolVersion();
-                protocol.iceRead(s);
+                protocol.read__(s);
                 encoding = new Ice.EncodingVersion();
-                encoding.iceRead(s);
+                encoding.read__(s);
             }
             else
             {
@@ -749,7 +749,7 @@ namespace IceInternal
             LocatorInfo locatorInfo = null;
             if(_defaultLocator != null)
             {
-                if(!((Ice.ObjectPrxHelperBase)_defaultLocator).iceReference().getEncoding().Equals(encoding))
+                if(!((Ice.ObjectPrxHelperBase)_defaultLocator).reference__().getEncoding().Equals(encoding))
                 {
                     locatorInfo = instance_.locatorManager().get(
                         (Ice.LocatorPrx)_defaultLocator.ice_encodingVersion(encoding));
@@ -789,7 +789,7 @@ namespace IceInternal
                 Ice.LocatorPrx locator = Ice.LocatorPrxHelper.uncheckedCast(_communicator.propertyToProxy(property));
                 if(locator != null)
                 {
-                    if(!((Ice.ObjectPrxHelperBase)locator).iceReference().getEncoding().Equals(encoding))
+                    if(!((Ice.ObjectPrxHelperBase)locator).reference__().getEncoding().Equals(encoding))
                     {
                         locatorInfo = instance_.locatorManager().get(
                             (Ice.LocatorPrx)locator.ice_encodingVersion(encoding));
diff --git a/csharp/src/Ice/RequestHandlerFactory.cs b/csharp/src/Ice/RequestHandlerFactory.cs
index 1e4058738c6..c30707f2492 100644
--- a/csharp/src/Ice/RequestHandlerFactory.cs
+++ b/csharp/src/Ice/RequestHandlerFactory.cs
@@ -26,7 +26,7 @@ namespace IceInternal
                 Ice.ObjectAdapter adapter = _instance.objectAdapterFactory().findObjectAdapter(proxy);
                 if(adapter != null)
                 {
-                    return proxy.iceSetRequestHandler(new CollocatedRequestHandler(rf, adapter));
+                    return proxy.setRequestHandler__(new CollocatedRequestHandler(rf, adapter));
                 }
             }
 
@@ -54,7 +54,7 @@ namespace IceInternal
             {
                 rf.getConnection(handler);
             }
-            return proxy.iceSetRequestHandler(handler.connect(proxy));
+            return proxy.setRequestHandler__(handler.connect(proxy));
         }
 
         internal void
diff --git a/csharp/src/Ice/RouterInfo.cs b/csharp/src/Ice/RouterInfo.cs
index 87f786ff0f2..1a5fe9b0131 100644
--- a/csharp/src/Ice/RouterInfo.cs
+++ b/csharp/src/Ice/RouterInfo.cs
@@ -207,7 +207,7 @@ namespace IceInternal
                         //
                         // If getClientProxy() return nil, use router endpoints.
                         //
-                        _clientEndpoints = ((Ice.ObjectPrxHelperBase)_router).iceReference().getEndpoints();
+                        _clientEndpoints = ((Ice.ObjectPrxHelperBase)_router).reference__().getEndpoints();
                     }
                     else
                     {
@@ -223,7 +223,7 @@ namespace IceInternal
                             clientProxy = clientProxy.ice_timeout(_router.ice_getConnection().timeout());
                         }
 
-                        _clientEndpoints = ((Ice.ObjectPrxHelperBase)clientProxy).iceReference().getEndpoints();
+                        _clientEndpoints = ((Ice.ObjectPrxHelperBase)clientProxy).reference__().getEndpoints();
                     }
                 }
                 return _clientEndpoints;
@@ -240,7 +240,7 @@ namespace IceInternal
                 }
 
                 serverProxy = serverProxy.ice_router(null); // The server proxy cannot be routed.
-                _serverEndpoints = ((Ice.ObjectPrxHelperBase)serverProxy).iceReference().getEndpoints();
+                _serverEndpoints = ((Ice.ObjectPrxHelperBase)serverProxy).reference__().getEndpoints();
                 return _serverEndpoints;
             }
         }
diff --git a/csharp/src/Ice/TraceUtil.cs b/csharp/src/Ice/TraceUtil.cs
index 8aec8ed6de9..cb18fb957a9 100644
--- a/csharp/src/Ice/TraceUtil.cs
+++ b/csharp/src/Ice/TraceUtil.cs
@@ -183,7 +183,7 @@ namespace IceInternal
                 }
 
                 Ice.Identity identity = new Ice.Identity();
-                identity.iceRead(str);
+                identity.read__(str);
                 s.Write("\nidentity = " + Ice.Util.identityToString(identity, toStringMode));
 
                 string[] facet = str.readStringSeq();
diff --git a/csharp/src/Ice/UdpEndpointI.cs b/csharp/src/Ice/UdpEndpointI.cs
index 0bcdfc61c82..bdaa9ef35e9 100644
--- a/csharp/src/Ice/UdpEndpointI.cs
+++ b/csharp/src/Ice/UdpEndpointI.cs
@@ -259,8 +259,8 @@ namespace IceInternal
             base.streamWriteImpl(s);
             if(s.getEncoding().Equals(Ice.Util.Encoding_1_0))
             {
-                Ice.Util.Protocol_1_0.iceWrite(s);
-                Ice.Util.Encoding_1_0.iceWrite(s);
+                Ice.Util.Protocol_1_0.write__(s);
+                Ice.Util.Encoding_1_0.write__(s);
             }
             // Not transmitted.
             //s.writeBool(_connect);
diff --git a/csharp/src/Ice/UnknownSlicedValue.cs b/csharp/src/Ice/UnknownSlicedValue.cs
index f4bbe9ba0f6..4f31945a855 100644
--- a/csharp/src/Ice/UnknownSlicedValue.cs
+++ b/csharp/src/Ice/UnknownSlicedValue.cs
@@ -32,16 +32,16 @@ namespace Ice
             return _unknownTypeId;
         }
 
-        public override void iceWrite(OutputStream iceOs)
+        public override void write__(OutputStream os__)
         {
-            iceOs.startValue(_slicedData);
-            iceOs.endValue();
+            os__.startValue(_slicedData);
+            os__.endValue();
         }
 
-        public override void iceRead(InputStream iceIs)
+        public override void read__(InputStream is__)
         {
-            iceIs.startValue();
-            _slicedData = iceIs.endValue(true);
+            is__.startValue();
+            _slicedData = is__.endValue(true);
         }
 
         private string _unknownTypeId;
diff --git a/csharp/src/Ice/Value.cs b/csharp/src/Ice/Value.cs
index 366fd2532b3..cf4fd0144d7 100644
--- a/csharp/src/Ice/Value.cs
+++ b/csharp/src/Ice/Value.cs
@@ -14,7 +14,7 @@ namespace Ice
     [Serializable]
     public abstract class Value : ICloneable
     {
-        public static readonly string s_iceId = "::Ice::Object";
+        public static readonly string static_id__ = "::Ice::Object";
 
         /// <summary>
         /// Returns the Slice type ID of the interface supported by this object.
@@ -22,7 +22,7 @@ namespace Ice
         /// <returns>The return value is always ::Ice::Object.</returns>
         public static string ice_staticId()
         {
-            return s_iceId;
+            return static_id__;
         }
 
         /// <summary>
@@ -31,7 +31,7 @@ namespace Ice
         /// <returns>The return value is always ::Ice::Object.</returns>
         public virtual string ice_id()
         {
-            return s_iceId;
+            return static_id__;
         }
 
         /// <summary>
@@ -50,25 +50,25 @@ namespace Ice
         {
         }
 
-        public virtual void iceWrite(OutputStream iceOs)
+        public virtual void write__(OutputStream os__)
         {
-            iceOs.startValue(null);
-            iceWriteImpl(iceOs);
-            iceOs.endValue();
+            os__.startValue(null);
+            writeImpl__(os__);
+            os__.endValue();
         }
 
-        public virtual void iceRead(InputStream iceIs)
+        public virtual void read__(InputStream is__)
         {
-            iceIs.startValue();
-            iceReadImpl(iceIs);
-            iceIs.endValue(false);
+            is__.startValue();
+            readImpl__(is__);
+            is__.endValue(false);
         }
 
-        protected virtual void iceWriteImpl(OutputStream iceOs)
+        protected virtual void writeImpl__(OutputStream os__)
         {
         }
 
-        protected virtual void iceReadImpl(InputStream iceIs)
+        protected virtual void readImpl__(InputStream is__)
         {
         }
 
@@ -95,16 +95,16 @@ namespace Ice
             return id_;
         }
 
-        protected override void iceWriteImpl(OutputStream iceOs)
+        protected override void writeImpl__(OutputStream os__)
         {
-            iceOs.startSlice(ice_id(), -1, true);
-            iceOs.endSlice();
+            os__.startSlice(ice_id(), -1, true);
+            os__.endSlice();
         }
 
-        protected override void iceReadImpl(InputStream iceIs)
+        protected override void readImpl__(InputStream is__)
         {
-            iceIs.startSlice();
-            iceIs.endSlice();
+            is__.startSlice();
+            is__.endSlice();
         }
 
         private string id_;
diff --git a/csharp/src/Ice/ValueWriter.cs b/csharp/src/Ice/ValueWriter.cs
index 811b3f0c8a0..9973e8a51d4 100644
--- a/csharp/src/Ice/ValueWriter.cs
+++ b/csharp/src/Ice/ValueWriter.cs
@@ -70,7 +70,7 @@ namespace IceInternal
                 {
                     writeName(name, output);
                     Ice.ObjectPrxHelperBase proxy = (Ice.ObjectPrxHelperBase)val;
-                    output.print(proxy.iceReference().ToString());
+                    output.print(proxy.reference__().ToString());
                 }
                 else if(val is Ice.Object)
                 {
diff --git a/csharp/test/Ice/optional/AllTests.cs b/csharp/test/Ice/optional/AllTests.cs
index b012684c7d3..522d0ad9900 100644
--- a/csharp/test/Ice/optional/AllTests.cs
+++ b/csharp/test/Ice/optional/AllTests.cs
@@ -1021,7 +1021,7 @@ public class AllTests : TestCommon.TestApp
             os.startEncapsulation();
             os.writeOptional(2, Ice.OptionalFormat.VSize);
             os.writeSize(1);
-            p1.Value.iceWrite(os);
+            p1.Value.write__(os);
             os.endEncapsulation();
             inEncaps = os.finished();
             initial.ice_invoke("opSmallStruct", Ice.OperationMode.Normal, inEncaps, out outEncaps);
@@ -1030,11 +1030,11 @@ public class AllTests : TestCommon.TestApp
             test(@in.readOptional(1, Ice.OptionalFormat.VSize));
             @in.skipSize();
             Test.SmallStruct f = new Test.SmallStruct();
-            f.iceRead(@in);
+            f.read__(@in);
             test(f.m == (byte)56);
             test(@in.readOptional(3, Ice.OptionalFormat.VSize));
             @in.skipSize();
-            f.iceRead(@in);
+            f.read__(@in);
             test(f.m == (byte)56);
             @in.endEncapsulation();
 
@@ -1070,7 +1070,7 @@ public class AllTests : TestCommon.TestApp
             os.startEncapsulation();
             os.writeOptional(2, Ice.OptionalFormat.VSize);
             os.writeSize(4);
-            p1.Value.iceWrite(os);
+            p1.Value.write__(os);
             os.endEncapsulation();
             inEncaps = os.finished();
             initial.ice_invoke("opFixedStruct", Ice.OperationMode.Normal, inEncaps, out outEncaps);
@@ -1079,11 +1079,11 @@ public class AllTests : TestCommon.TestApp
             test(@in.readOptional(1, Ice.OptionalFormat.VSize));
             @in.skipSize();
             Test.FixedStruct f = new Test.FixedStruct();
-            f.iceRead(@in);
+            f.read__(@in);
             test(f.m == 56);
             test(@in.readOptional(3, Ice.OptionalFormat.VSize));
             @in.skipSize();
-            f.iceRead(@in);
+            f.read__(@in);
             test(f.m == 56);
             @in.endEncapsulation();
 
@@ -1124,7 +1124,7 @@ public class AllTests : TestCommon.TestApp
             os.startEncapsulation();
             os.writeOptional(2, Ice.OptionalFormat.FSize);
             int pos = os.startSize();
-            p1.Value.iceWrite(os);
+            p1.Value.write__(os);
             os.endSize(pos);
             os.endEncapsulation();
             inEncaps = os.finished();
@@ -1134,11 +1134,11 @@ public class AllTests : TestCommon.TestApp
             test(@in.readOptional(1, Ice.OptionalFormat.FSize));
             @in.skip(4);
             Test.VarStruct v = new Test.VarStruct();
-            v.iceRead(@in);
+            v.read__(@in);
             test(v.m.Equals("test"));
             test(@in.readOptional(3, Ice.OptionalFormat.FSize));
             @in.skip(4);
-            v.iceRead(@in);
+            v.read__(@in);
             test(v.m.Equals("test"));
             @in.endEncapsulation();
 
diff --git a/csharp/test/Ice/stream/AllTests.cs b/csharp/test/Ice/stream/AllTests.cs
index 19eef43c41d..e7aba7107df 100644
--- a/csharp/test/Ice/stream/AllTests.cs
+++ b/csharp/test/Ice/stream/AllTests.cs
@@ -69,7 +69,7 @@ public class AllTests : TestCommon.TestApp
 
         public override void write(Ice.OutputStream outS)
         {
-            obj.iceWrite(outS);
+            obj.write__(outS);
             called = true;
         }
 
@@ -82,7 +82,7 @@ public class AllTests : TestCommon.TestApp
         public override void read(Ice.InputStream inS)
         {
             obj = new MyClass();
-            obj.iceRead(inS);
+            obj.read__(inS);
             called = true;
         }
 
diff --git a/csharp/test/Slice/keyword/Client.cs b/csharp/test/Slice/keyword/Client.cs
index 5e0b1393fd9..e2835a837ba 100644
--- a/csharp/test/Slice/keyword/Client.cs
+++ b/csharp/test/Slice/keyword/Client.cs
@@ -24,7 +24,7 @@ public class Client
     public sealed class caseI : @abstract.caseDisp_
     {
         public override Task<int>
-        catchAsync(int @checked,  Ice.Current iceCurrent)
+        catchAsync(int @checked,  Ice.Current current__)
         {
             return Task<int>.FromResult(0);
         }
@@ -32,14 +32,14 @@ public class Client
 
     public sealed class decimalI : @abstract.decimalDisp_
     {
-        public override void @default(Ice.Current iceCurrent)
+        public override void @default(Ice.Current current__)
         {
         }
     }
 
     public sealed class delegateI : @abstract.delegateDisp_
     {
-        public override void foo(@abstract.casePrx @else, out int @event, Ice.Current iceCurrent)
+        public override void foo(@abstract.casePrx @else, out int @event, Ice.Current current__)
         {
             @event = 0;
         }
@@ -48,7 +48,7 @@ public class Client
     public sealed class explicitI : @abstract.explicitDisp_
     {
         public override Task<int>
-        catchAsync(int @checked,  Ice.Current iceCurrent)
+        catchAsync(int @checked,  Ice.Current current__)
         {
             return Task<int>.FromResult(0);
         }
@@ -58,7 +58,7 @@ public class Client
             test(current.operation == "default");
         }
 
-        public override void foo(@abstract.casePrx @else, out int @event, Ice.Current iceCurrent)
+        public override void foo(@abstract.casePrx @else, out int @event, Ice.Current current__)
         {
             @event = 0;
         }