Replaced all double-underscores in C#

1 files changed, 44 insertions, 44 deletions

diff --git a/csharp/src/Ice/Object.cs b/csharp/src/Ice/Object.cs
index 0b888955616..a05266369e0 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> dispatch__(IceInternal.Incoming inc, Current current);
+        Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inc, Current current);
     }
 
     /// <summary>
@@ -94,7 +94,7 @@ namespace Ice
             return MemberwiseClone();
         }
 
-        public static readonly string[] ids__ =
+        private 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(ids__[0]);
+            return s.Equals(_ids[0]);
         }
 
-        public static Task<Ice.OutputStream> ice_isA___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
+        public static Task<Ice.OutputStream> iceD_ice_isA(Ice.Object obj, IceInternal.Incoming inS, Current current)
         {
-            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__);
+            InputStream istr = inS.startReadParams();
+            var id = istr.readString();
+            inS.endReadParams();
+            var ret = obj.ice_isA(id, current);
+            var ostr = inS.startWriteParams();
+            ostr.writeBool(ret);
+            inS.endWriteParams(ostr);
+            inS.setResult(ostr);
             return null;
         }
 
@@ -132,11 +132,11 @@ namespace Ice
             // Nothing to do.
         }
 
-        public static Task<Ice.OutputStream> ice_ping___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
+        public static Task<Ice.OutputStream> iceD_ice_ping(Ice.Object obj, IceInternal.Incoming inS, Current current)
         {
-            inS__.readEmptyParams();
-            __obj.ice_ping(__current);
-            inS__.setResult(inS__.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 ids__;
+            return _ids;
         }
 
-        public static Task<Ice.OutputStream> ice_ids___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
+        public static Task<Ice.OutputStream> iceD_ice_ids(Ice.Object obj, IceInternal.Incoming inS, Current current)
         {
-            inS__.readEmptyParams();
-            var ret__ = __obj.ice_ids(__current);
-            var os__ = inS__.startWriteParams();
-            os__.writeStringSeq(ret__);
-            inS__.endWriteParams(os__);
-            inS__.setResult(os__);
+            inS.readEmptyParams();
+            var ret = obj.ice_ids(current);
+            var ostr = inS.startWriteParams();
+            ostr.writeStringSeq(ret);
+            inS.endWriteParams(ostr);
+            inS.setResult(ostr);
             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 ids__[0];
+            return _ids[0];
         }
 
-        public static Task<Ice.OutputStream> ice_id___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
+        public static Task<Ice.OutputStream> iceD_ice_id(Ice.Object obj, IceInternal.Incoming inS, Current current)
         {
-            inS__.readEmptyParams();
-            var __ret = __obj.ice_id(__current);
-            var os__ = inS__.startWriteParams();
-            os__.writeString(__ret);
-            inS__.endWriteParams(os__);
-            inS__.setResult(os__);
+            inS.readEmptyParams();
+            var ret = obj.ice_id(current);
+            var ostr = inS.startWriteParams();
+            ostr.writeString(ret);
+            inS.endWriteParams(ostr);
+            inS.setResult(ostr);
             return null;
         }
 
@@ -188,10 +188,10 @@ namespace Ice
         /// <returns>The return value is always ::Ice::Object.</returns>
         public static string ice_staticId()
         {
-            return ids__[0];
+            return _ids[0];
         }
 
-        private static readonly string[] all__ = 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 dispatch__(inc, inc.getCurrent());
+            return iceDispatch(inc, inc.getCurrent());
         }
 
-        public virtual Task<Ice.OutputStream> dispatch__(IceInternal.Incoming inc, Current current)
+        public virtual Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inc, Current current)
         {
-            int pos = System.Array.BinarySearch(all__, 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 ice_id___(this, inc, current);
+                    return iceD_ice_id(this, inc, current);
                 }
                 case 1:
                 {
-                    return ice_ids___(this, inc, current);
+                    return iceD_ice_ids(this, inc, current);
                 }
                 case 2:
                 {
-                    return ice_isA___(this, inc, current);
+                    return iceD_ice_isA(this, inc, current);
                 }
                 case 3:
                 {
-                    return ice_ping___(this, inc, current);
+                    return iceD_ice_ping(this, inc, current);
                 }
             }
 
@@ -260,7 +260,7 @@ namespace Ice
             return "???";
         }
 
-        public static void checkMode__(OperationMode expected, OperationMode received)
+        public static void iceCheckMode(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> dispatch__(IceInternal.Incoming inS, Current current)
+        public override Task<Ice.OutputStream> iceDispatch(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> dispatch__(IceInternal.Incoming inS, Current current)
+        public override Task<Ice.OutputStream> iceDispatch(IceInternal.Incoming inS, Current current)
         {
             byte[] inEncaps = inS.readParamEncaps();
             return ice_invokeAsync(inEncaps, current).ContinueWith((Task<Ice.Object_Ice_invokeResult> t) =>