How to unit test private method in .Net Core application which does not support "PrivateObject"

wish of those help The @dynamic preprocessor command tells the compiler that the methods will be provided at runtime. It is the managed object context that provides the methods based on information taken from the managed object model. Without the context, the class doesn't have the actual method and can't respond to the selector.

Any of those help Maybe this is a comment, but its too big to fit in the comment area.
I took your class definitions and tried this out -

class A
{
    public:
    int pub1;
    private:
    int prvt1;
    protected:
    int proc1;
};


class B : public A
{

    //public int pub1;//This variable is because of inheritacne and is internal.
    //public int proc1;//This variable is because of inheritacne and is internal.
    public:
    int pub2;
    private:
    int prvt2;
    protected:
    int pro2;
};

int main()
{
    B* b = new B();
    b->pub2 = 1;
    b->proc1 = 2;
}

prog.cpp: In function ‘int main()’:
prog.cpp:8:9: error: ‘int A::proc1’ is protected
prog.cpp:29:8: error: within this context

this will help Result has an unfortunate side effect of wrapping all exceptions in AggregateException. This makes testing the error path much more painful.
But even if you decide you could live with that, you still have the problem of calling multiple async methods within a single test; i.e., if your test setup also requires async work. To do it in a blocking way, you'd have to either refactor your test method into a separate async method, or wrap it in an async delegate and either execute it directly or toss it into Task.Run. Not impossible, but not convenient either.

this one helps. Remove Type like belove and use Object instead. Also see how to use it in question update above

bool sent = (bool) po.Invoke("DoSomething", 
                new Object[] { id, name, location, ds, 500, 120 });

Hope that helps The reason for data providers to be decoupled from test case setup flow is that they can be defined as external class methods. Also it is about injecting data into tests. Consider such code:

class SampleTest extends PHPUnit_Framework_TestCase
{
    public function __construct($name = null, array $data = array(), $dataName = '') {
        parent::__construct($name, $data, $dataName);
        var_dump('constructed');
    }
    public static function setUpBeforeClass() {
        parent::setUpBeforeClass();
        var_dump('beforeClass');
    }

    public function setUp(){
        var_dump('before');
    }

    /**
     * @dataProvider sampleDataProvider
     */
    public function testMethod($expected, $actual) {
        var_dump('test');
        $this->assertEquals($expected, $actual);
    }

    public function sampleDataProvider() {
        var_dump('dataProvider');
        return [
            [1, 1],
            [2, 2],
        ];
    }
}

class AnotherSampleTest extends PHPUnit_Framework_TestCase
{
    public function testMethod() {
        foreach ($this->sampleDataProvider() as $dataSet) {
            list($expected, $actual) = $dataSet;
            $this->assertEquals($expected, $actual);
        }
    }

    public function sampleDataProvider() {
        return [
            [1, 1],
            [2, 2],
        ];
    }
}