private-members

I have the following code : public class MyClass { private readonly string name; public string Name { get { return name; } } public MyClass(string name) { this.name = name; } } class Program { static void Main(string[] args) { MyClass mc = new MyClass("SomeName"); } } Is there any way I can change the value of mc.name without modifying the class? You can only use reflection typeof(MyClass) .GetField("name",BindingFlags.Instance|BindingFlags.NonPublic) .SetValue(myclassInstance, 123); Adam Flanagan With reflection , yes ( Can I change a private readonly field in C# using reflection? ), but

It seems as though the general consensus of the testing community is to not test private methods. Instead, you should test private methods by testing the public methods that invoke them . However, something just doesn't feel right to me. Let's take this method for example: /** * Returns the base name of the output generator class. If the class is named * Reno_OutputGenerator_HTML, this would return "HTML". * * @return string */ protected function getName() { $class = get_class($this); $matches = array(); if (preg_match('/^Reno_OutputGenerator_(.+)$', $class, $matches)) { return $matches[1]; }

I'm working on a bit of code where I'm attempting to hide some private variables inside closures. The thing is the environment is fairly constrained in terms of memory, so I'm also concerned with keeping the overall footprint of the classes low. What is the impact of using closures to hide private instance variables and methods when compared to just making all methods and variables on an object public? Would an instance of the one using closures take up more memory than an instance that did not use closures? If so, how much more memory would I expect to use? my code would look like this

I have a public method in a class that internally calls a particular private method within that class. It looks something like this : public class MyClass : IMyClassInterface { public List<int> MyMethod(int a, int b) { MyPrivateMethod(a, b, ref varList, ref someVal); } private void MyPrivateMethod(int a, int b, ref List<int> varList, ref double someval) { } } Now, I basically want to test this public method using NUnit. I am using NMock 2.0 for mocking. How do I do it? Since, it internally calls this private method which I do not want to make public. Or is there a way to do it if I turn the

as far as I know Visual Studio 2012 will not support Private Accessors. Can you give me some infos on possible alternatives? PrivateObject.Invoke() is not the best solution for me. Thank you in advance! Mark your members as "internal" and use the InternalsVisibleTo attribute. Simple to use and no type safety issues. Maybe this posting Home-made Private Accessor for Visual Studio 2012+ will help you creating your own Private Accessor. Regards, Stefan I started using the Dynamic Private Accessor feature that is part of the nuget package Chaining Assertion for MSTest and I am rather happy with it

This question already has answers here : What is the meaning of a single and a double underscore before an object name? (14 answers) Closed 9 months ago . Ok I think I have understood the use of one and two heading underscores in Python. Correct me if I am wrong, In the case of one underscore, the underscore prevents the from X import * statement to import this kind of variables. In the case of two underscores, the variable's name is prepended with the name of the class it belongs to allow a higher level of "privateness". My question now is: why not use two underscores only? In which cases one

Why does this happen? http://coliru.stacked-crooked.com/a/e1376beff0c157a1 class Base{ private: virtual void do_run() = 0; public: void run(){ do_run(); } }; class A : public Base { public: // uplift ?? virtual void do_run() override {} }; int main() { A a; a.do_run(); } Why can I override a PRIVATE virtual method as public? According to https://en.cppreference.com/w/cpp/language/virtual#In_detail overwriting a base's virtual member function only care about the function name, parameters, const/volatile-ness and ref qualifier. It doesn't care about return type, access modifier or other things